Help on module essentia.standard in essentia:
NAME essentia.standard
xxxxxxxxxxAfterMaxToBeforeMaxEnergyRatio = class Algo(Algorithm)| AfterMaxToBeforeMaxEnergyRatio||| Inputs:|| [vector_real] pitch - the array of pitch values [Hz]||| Outputs:|| [real] afterMaxToBeforeMaxEnergyRatio - the ratio between the pitch energy after the pitch maximum to the pitch energy before the pitch maximum||| Description:|| This algorithm computes the ratio between the pitch energy after the pitch| maximum and the pitch energy before the pitch maximum. Sounds having an| monotonically ascending pitch or one unique pitch will show a value of (0,1],| while sounds having a monotonically descending pitch will show a value of| [1,inf). In case there is no energy before the max pitch, the algorithm will| return the energy after the maximum pitch.|| The algorithm throws exception when input is either empty or contains only| zeros.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).AllPass = class Algo(Algorithm)| AllPass||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| bandwidth:| real ∈ (0,inf) (default = 500)| the bandwidth of the filter [Hz] (used only for 2nd-order filters)|| cutoffFrequency:| real ∈ (0,inf) (default = 1500)| the cutoff frequency for the filter [Hz]|| order:| integer ∈ {1,2} (default = 1)| the order of the filter|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements a IIR all-pass filter of order 1 or 2. Because of| its dependence on IIR, IIR's requirements are inherited.|| References:| [1] U. Zölzer, DAFX - Digital Audio Effects, p. 43,| John Wiley & Sons, 2002|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).AudioLoader = class Algo(Algorithm)| AudioLoader||| Outputs:|| [vector_stereosample] audio - the input audio signal| [real] sampleRate - the sampling rate of the audio signal [Hz]| [integer] numberChannels - the number of channels| [string] md5 - the MD5 checksum of raw undecoded audio payload| [integer] bit_rate - the bit rate of the input audio, as reported by the decoder codec| [string] codec - the codec that is used to decode the input audio||| Parameters:|| audioStream:| integer ∈ [0,inf) (default = 0)| audio stream index to be loaded. Other streams are no taken into account| (e.g. if stream 0 is video and 1 is audio use index 0 to access it.)|| computeMD5:| bool ∈ {true,false} (default = false)| compute the MD5 checksum|| filename:| string| the name of the file from which to read||| Description:|| This algorithm loads the single audio stream contained in a given audio or| video file. Supported formats are all those supported by the FFmpeg library| including wav, aiff, flac, ogg and mp3.|| This algorithm will throw an exception if it was not properly configured| which is normally due to not specifying a valid filename. Invalid names| comprise those with extensions different than the supported formats and non| existent files. If using this algorithm on Windows, you must ensure that the| filename is encoded as UTF-8|| Note: ogg files are decoded in reverse phase, due to be using ffmpeg library.|| References:| [1] WAV - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Wav| [2] Audio Interchange File Format - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Aiff| [3] Free Lossless Audio Codec - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Flac| [4] Vorbis - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Vorbis| [5] MP3 - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Mp3|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).AudioOnsetsMarker = class Algo(Algorithm)| AudioOnsetsMarker||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the input signal mixed with bursts at onset locations||| Parameters:|| onsets:| vector_real (default = [])| the list of onset locations [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the output signal [Hz]|| type:| string ∈ {beep,noise} (default = "beep")| the type of sound to be added on the event||| Description:|| This algorithm creates a wave file in which a given audio signal is mixed| with a series of time onsets. The sonification of the onsets can be heard as| beeps, or as short white noise pulses if configured to do so.|| This algorithm will throw an exception if parameter "filename" is not| supplied|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).AudioWriter = class Algo(Algorithm)| AudioWriter||| Inputs:|| [vector_stereosample] audio - the audio signal||| Parameters:|| bitrate:| integer ∈ {32,40,48,56,64,80,96,112,128,144,160,192,224,256,320} (default = 192)| the audio bit rate for compressed formats [kbps]|| filename:| string| the name of the encoded file|| format:| string ∈ {wav,aiff,mp3,ogg,flac} (default = "wav")| the audio output format|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm encodes an input stereo signal into a stereo audio file.|| The algorithm uses the FFmpeg library. Supported formats are wav, aiff, mp3,| flac and ogg. The default FFmpeg encoders are used for each format.|| An exception is thrown when other extensions are given. Note that to encode| in mp3 format it is mandatory that FFmpeg was configured with mp3 enabled.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).AutoCorrelation = class Algo(Algorithm)| AutoCorrelation||| Inputs:|| [vector_real] array - the array to be analyzed||| Outputs:|| [vector_real] autoCorrelation - the autocorrelation vector||| Parameters:|| frequencyDomainCompression:| real ∈ (0, inf) (default = 0.5)| factor at which FFT magnitude is compressed (only used if 'generalized' is| set to true, see [3])|| generalized:| bool ∈ {true,false} (default = false)| bool value to indicate whether to compute the 'generalized' autocorrelation| as described in [3]|| normalization:| string ∈ {standard,unbiased} (default = "standard")| type of normalization to compute: either 'standard' (default) or 'unbiased'||| Description:|| This algorithm computes the autocorrelation vector of a signal.| It uses the version most commonly used in signal processing, which doesn't| remove the mean from the observations.| Using the 'generalized' option this algorithm computes autocorrelation as| described in [3].|| References:| [1] Autocorrelation -- from Wolfram MathWorld,| http://mathworld.wolfram.com/Autocorrelation.html|| [2] Autocorrelation - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Autocorrelation|| [3] Tolonen T., and Karjalainen, M. (2000). A computationally efficient| multipitch analysis model.| IEEE Transactions on Audio, Speech, and Language Processing, 8(6), 708-716.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BFCC = class Algo(Algorithm)| BFCC||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energies in bark bands| [vector_real] bfcc - the bark frequency cepstrum coefficients||| Parameters:|| dctType:| integer ∈ [2,3] (default = 2)| the DCT type|| highFrequencyBound:| real ∈ (0,inf) (default = 11000)| the upper bound of the frequency range [Hz]|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of input spectrum|| liftering:| integer ∈ [0,inf) (default = 0)| the liftering coefficient. Use '0' to bypass it|| logType:| string ∈ {natural,dbpow,dbamp,log} (default = "dbamp")| logarithmic compression type. Use 'dbpow' if working with power and 'dbamp'| if working with magnitudes|| lowFrequencyBound:| real ∈ [0,inf) (default = 0)| the lower bound of the frequency range [Hz]|| normalize:| string ∈ {unit_sum,unit_max} (default = "unit_sum")| 'unit_max' makes the vertex of all the triangles equal to 1, 'unit_sum'| makes the area of all the triangles equal to 1|| numberBands:| integer ∈ [1,inf) (default = 40)| the number of bark bands in the filter|| numberCoefficients:| integer ∈ [1,inf) (default = 13)| the number of output cepstrum coefficients|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum|| weighting:| string ∈ {warping,linear} (default = "warping")| type of weighting function for determining triangle area||| Description:|| This algorithm computes the bark-frequency cepstrum coefficients of a| spectrum. Bark bands and their subsequent usage in cepstral analysis have| shown to be useful in percussive content [1, 2]| This algorithm is implemented using the Bark scaling approach in the Rastamat| version of the MFCC algorithm and in a similar manner to the MFCC-FB40| default specs:|| http://www.ee.columbia.edu/ln/rosa/matlab/rastamat/| - filterbank of 40 bands from 0 to 11000Hz| - take the log value of the spectrum energy in each bark band| - DCT of the 40 bands down to 13 mel coefficients|| The parameters of this algorithm can be configured in order to behave like| Rastamat [3] as follows:| - type = 'power'| - weighting = 'linear'| - lowFrequencyBound = 0| - highFrequencyBound = 8000| - numberBands = 26| - numberCoefficients = 13| - normalize = 'unit_max'| - dctType = 3| - logType = 'log'| - liftering = 22|| In order to completely behave like Rastamat the audio signal has to be scaled| by 2^15 before the processing and if the Windowing and FrameCutter algorithms| are used they should also be configured as follows.|| FrameGenerator:| - frameSize = 1102| - hopSize = 441| - startFromZero = True| - validFrameThresholdRatio = 1|| Windowing:| - type = 'hann'| - size = 1102| - zeroPadding = 946| - normalized = False|| This algorithm depends on the algorithms TriangularBarkBands (not the regular| BarkBands algo as it is non-configurable) and DCT and therefore inherits| their parameter restrictions. An exception is thrown if any of these| restrictions are not met. The input "spectrum" is passed to the| TriangularBarkBands algorithm and thus imposes TriangularBarkBands' input| requirements. Exceptions are inherited by TriangualrBarkBands as well as by| DCT.|| References:| [1] P. Herrera, A. Dehamel, and F. Gouyon, "Automatic labeling of unpitched| percussion sounds in| Audio Engineering Society 114th Convention, 2003,| [2] W. Brent, "Cepstral Analysis Tools for Percussive Timbre Identification| in| Proceedings of the 3rd International Pure Data Convention, Sao Paulo,| Brazil, 2009,|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BPF = class Algo(Algorithm)| BPF||| Inputs:|| [real] x - the input coordinate (x-axis)||| Outputs:|| [real] y - the output coordinate (y-axis)||| Parameters:|| xPoints:| vector_real (default = [0, 1])| the x-coordinates of the points forming the break-point function (the| points must be arranged in ascending order and cannot contain duplicates)|| yPoints:| vector_real (default = [0, 1])| the y-coordinates of the points forming the break-point function||| Description:|| This algorithm implements a break point function which linearly interpolates| between discrete xy-coordinates to construct a continuous function.|| Exceptions are thrown when the size the vectors specified in parameters is| not equal and at least they contain two elements. Also if the parameter| vector for x-coordinates is not sorted ascendantly. A break point function| cannot interpolate outside the range specified in parameter "xPoints". In| that case an exception is thrown.|| References:| [1] Linear interpolation - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Linear_interpolation|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm i...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BandPass = class Algo(Algorithm)| BandPass||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| bandwidth:| real ∈ (0,inf) (default = 500)| the bandwidth of the filter [Hz]|| cutoffFrequency:| real ∈ (0,inf) (default = 1500)| the cutoff frequency for the filter [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements a 2nd order IIR band-pass filter. Because of its| dependence on IIR, IIR's requirements are inherited.|| References:| [1] U. Zölzer, DAFX - Digital Audio Effects, 2nd edition, p. 55,| John Wiley & Sons, 2011|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BandReject = class Algo(Algorithm)| BandReject||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| bandwidth:| real ∈ (0,inf) (default = 500)| the bandwidth of the filter [Hz]|| cutoffFrequency:| real ∈ (0,inf) (default = 1500)| the cutoff frequency for the filter [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements a 2nd order IIR band-reject filter. Because of its| dependence on IIR, IIR's requirements are inherited.|| References:| [1] U. Zölzer, DAFX - Digital Audio Effects, 2nd edition, p. 55,| John Wiley & Sons, 2011|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BarkBands = class Algo(Algorithm)| BarkBands||| Inputs:|| [vector_real] spectrum - the input spectrum||| Outputs:|| [vector_real] bands - the energy of the bark bands||| Parameters:|| numberBands:| integer ∈ [1,28] (default = 27)| the number of desired barkbands|| sampleRate:| real ∈ [0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes energy in Bark bands of a spectrum. The band| frequencies are: [0.0, 50.0, 100.0, 150.0, 200.0, 300.0, 400.0, 510.0, 630.0,| 770.0, 920.0, 1080.0, 1270.0, 1480.0, 1720.0, 2000.0, 2320.0, 2700.0, 3150.0,| 3700.0, 4400.0, 5300.0, 6400.0, 7700.0, 9500.0, 12000.0, 15500.0, 20500.0,| 27000.0]. The first two Bark bands [0,100] and [100,200] have been split in| half for better resolution (because of an observed better performance in beat| detection). For each bark band the power-spectrum (mag-squared) is summed.|| This algorithm uses FrequencyBands and thus inherits its input requirements| and exceptions.|| References:| [1] The Bark Frequency Scale,| http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BeatTrackerDegara = class Algo(Algorithm)| BeatTrackerDegara||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] ticks - the estimated tick locations [s]||| Parameters:|| maxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| minTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]||| Description:|| This algorithm estimates the beat positions given an input signal. It| computes 'complex spectral difference' onset detection function and utilizes| the beat tracking algorithm (TempoTapDegara) to extract beats [1]. The| algorithm works with the optimized settings of 2048/1024 frame/hop size for| the computation of the detection function, with its posterior x2 resampling.)| While it has a lower accuracy than BeatTrackerMultifeature (see the| evaluation results in [2]), its computational speed is significantly higher,| which makes reasonable to apply this algorithm for batch processings of large| amounts of audio signals.|| Note that the algorithm requires the audio input with the 44100 Hz sampling| rate in order to function correctly.|| References:| [1] N. Degara, E. A. Rua, A. Pena, S. Torres-Guijarro, M. E. Davies, and| M. D. Plumbley, "Reliability-informed beat tracking of musical signals,"| IEEE Transactions on Audio, Speech, and Language Processing, vol. 20,| no. 1, pp. 290–301, 2012.|| [2] J.R. Zapata, M.E.P. Davies and E. Gómez, "Multi-feature beat| tracking,"| IEEE Transactions on Audio, Speech, and Language Processing, vol. 22,| no. 4, pp. 816-825, 2014.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BeatTrackerMultiFeature = class Algo(Algorithm)| BeatTrackerMultiFeature||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] ticks - the estimated tick locations [s]| [real] confidence - confidence of the beat tracker [0, 5.32]||| Parameters:|| maxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| minTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]||| Description:|| This algorithm estimates the beat positions given an input signal. It| computes a number of onset detection functions and estimates beat location| candidates from them using TempoTapDegara algorithm. Thereafter the best| candidates are selected using TempoTapMaxAgreement. The employed detection| functions, and the optimal frame/hop sizes used for their computation are:| - complex spectral difference (see 'complex' method in OnsetDetection| algorithm, 2048/1024 with posterior x2 upsample or the detection function)| - energy flux (see 'rms' method in OnsetDetection algorithm, the same| settings)| - spectral flux in Mel-frequency bands (see 'melflux' method in| OnsetDetection algorithm, the same settings)| - beat emphasis function (see 'beat_emphasis' method in| OnsetDetectionGlobal algorithm, 2048/512)| - spectral flux between histogrammed spectrum frames, measured by the| modified information gain (see 'infogain' method in OnsetDetectionGlobal| algorithm, 2048/512)|| You can follow these guidelines [2] to assess the quality of beats estimation| based on the computed confidence value:| - [0, 1) very low confidence, the input signal is hard for the| employed candidate beat trackers| - [1, 1.5] low confidence| - (1.5, 3.5] good confidence, accuracy around 80% in AMLt measure| - (3.5, 5.32] excellent confidence|| Note that the algorithm requires the audio input with the 44100 Hz sampling| rate in order to function correctly.|| References:| [1] J. Zapata, M. Davies and E. Gómez, "Multi-feature beat tracker,"| IEEE/ACM Transactions on Audio, Speech and Language Processing. 22(4),| 816-825, 2014|| [2] J.R. Zapata, A. Holzapfel, M.E.P. Davies, J.L. Oliveira, F. Gouyon,| "Assigning a confidence threshold on automatic beat annotation in large| datasets", International Society for Music Information Retrieval Conference| (ISMIR'12), pp. 157-162, 2012|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': "This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Beatogram = class Algo(Algorithm)| Beatogram||| Inputs:|| [vector_real] loudness - the loudness at each beat| [vector_vector_real] loudnessBandRatio - matrix of loudness ratios at each band and beat||| Outputs:|| [vector_vector_real] beatogram - filtered matrix loudness||| Parameters:|| size:| integer ∈ [1,inf) (default = 16)| number of beats for dynamic filtering||| Description:|| This algorithm filters the loudness matrix given by BeatsLoudness algorithm| in order to keep only the most salient beat band representation.| This algorithm has been found to be useful for estimating time signatures.|| Quality: experimental (not evaluated, do not use)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm fil...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BeatsLoudness = class Algo(Algorithm)| BeatsLoudness||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] loudness - the beat's energy in the whole spectrum| [vector_vector_real] loudnessBandRatio - the ratio of the beat's energy on each frequency band||| Parameters:|| beatDuration:| real ∈ (0,inf) (default = 0.0500000007451)| the duration of the window in which the beat will be restricted [s]|| beatWindowDuration:| real ∈ (0,inf) (default = 0.10000000149)| the duration of the window in which to look for the beginning of the beat| (centered around the positions in 'beats') [s]|| beats:| vector_real (default = [])| the list of beat positions (each position is in seconds)|| frequencyBands:| vector_real (default = [20, 150, 400, 3200, 7000, 22000])| the list of bands to compute energy ratios [Hz|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the spectrum energy of beats in an audio signal given| their positions. The energy is computed both on the whole frequency range and| for each of the specified frequency bands. See the SingleBeatLoudness| algorithm for a more detailed explanation.|| Note that the algorithm will output empty results in the case if no beats are| specified in the "beats" parameter.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BinaryOperator = class Algo(Algorithm)| BinaryOperator||| Inputs:|| [vector_real] array1 - the first operand input array| [vector_real] array2 - the second operand input array||| Outputs:|| [vector_real] array - the array containing the result of binary operation||| Parameters:|| type:| string ∈ {add,subtract,multiply,divide} (default = "add")| the type of the binary operator to apply to the input arrays||| Description:|| This algorithm performs basic arithmetical operations element by element| given two arrays.| Note:| - using this algorithm in streaming mode can cause diamond shape graphs| which have not been tested with the current scheduler. There is NO GUARANTEE| of its correct work for diamond shape graphs.| - for y<0, x/y is invalid|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm p...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BinaryOperatorStream = class Algo(Algorithm)| BinaryOperatorStream||| Inputs:|| [vector_real] array1 - the first operand input array| [vector_real] array2 - the second operand input array||| Outputs:|| [vector_real] array - the array containing the result of binary operation||| Parameters:|| type:| string ∈ {add,subtract,multiply,divide} (default = "add")| the type of the binary operator to apply to the input arrays||| Description:|| This algorithm performs basic arithmetical operations element by element| given two arrays.| Note:| - using this algorithm in streaming mode can cause diamond shape graphs| which have not been tested with the current scheduler. There is NO GUARANTEE| of its correct work for diamond shape graphs.| - for y<0, x/y is invalid|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm p...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BpmHistogram = class Algo(Algorithm)| BpmHistogram||| Inputs:|| [vector_real] novelty - the novelty curve||| Outputs:|| [real] bpm - mean BPM of the most salient tempo| [vector_real] bpmCandidates - list of the most salient BPM values| [vector_real] bpmMagnitudes - magnitudes of the most salient BPM values| [matrix_real] tempogram - spectrogram-like representation of tempo over time (frames of BPM magnitudes)| [vector_real] frameBpms - BPM values at each frame| [vector_real] ticks - time positions of ticks [s]| [vector_real] ticksMagnitude - ticks' strength (magnitude)| [vector_real] sinusoid - sinusoid whose peaks indicate tick positions||| Parameters:|| bpm:| real ∈ [0,inf) (default = 0)| bpm to induce a certain tempo tracking. Zero if unknown|| constantTempo:| bool ∈ {true,false} (default = false)| whether to consider constant tempo. Set to true when inducina specific| tempo|| frameRate:| real ∈ [1,inf) (default = 86.1328125)| the sampling rate of the novelty curve [frame/s]|| frameSize:| real ∈ [1,inf) (default = 4)| the minimum length to compute the FFT [s]|| maxBpm:| real ∈ (0,inf) (default = 560)| the maximum bpm to consider|| maxPeaks:| integer ∈ (0,inf] (default = 50)| the number of peaks to be considered at each spectrum|| minBpm:| real ∈ [0,inf) (default = 30)| the minimum bpm to consider|| overlap:| integer ∈ (0,inf) (default = 16)| the overlap factor|| tempoChange:| real ∈ [0,inf) (default = 5)| the minimum length to consider a change in tempo as stable [s]|| weightByMagnitude:| bool ∈ {true,false} (default = true)| whether to consider peaks' magnitude when building the histogram|| windowType:| string (default = "hann")| the window type to be used when computing the FFT|| zeroPadding:| integer ∈ [0,inf) (default = 0)| zero padding factor to compute the FFT [s]||| Description:|| This algorithm analyzes predominant periodicities in a signal given its| novelty curve [1] (see NoveltyCurve algorithm) or another onset detection| function (see OnsetDetection and OnsetDetectionGlobal). It estimates pulse| BPM values and time positions together with a half-wave rectified sinusoid| whose peaks represent the pulses present in the audio signal and their| magnitudes. The analysis is based on the FFT of the input novelty curve from| which salient periodicities are detected by thresholding. Temporal evolution| of these periodicities is output in the "tempogram". Candidate BPMs are then| detected based on a histogram of the observed periodicities weighted by their| energy in the tempogram. The sinusoidal model is constructed based on the| observed periodicities and their magnitudes with the estimated overall BPM as| a reference.|| The algorithm outputs:| - bpm: the mean of the most salient BPM values representing periodicities in| the signal (the mean BPM).| - bpmCandidates and bpmMagnitudes: list of the most salient BPM values and| their magnitudes (intensity). These two outputs can be helpful for taking an| alternative decision on estimation of the overall BPM.| - tempogram: spectrogram-like representation of the estimated salient| periodicities and their intensities over time (per-frame BPM magnitudes). It| is useful for detecting tempo variations and visualization of tempo| evolution.| - frameBpms: list of candidate BPM values at each frame. The candidate| values are similar to the mean BPM. If no candidates are found to be similar,| the mean value itself is used unless "tempoChange" seconds have triggered a| variation in tempo.| - ticks: time positions of ticks in seconds.| - ticksMagnitude: magnitude of each tick. Higher values correspond to higher| probability of correctly identified ticks.| - sinusoid: a sinusoidal model of the ticks' positions. The previous outputs| are based on detecting peaks of this half-wave rectified sinusoid. This model| can be used to obtain ticks using alternative peak detection algorithms if| necessary. Beware that the last few ticks may exceed the length of the audio| signal due to overlap factors. Therefore, this output should be always| checked against the length of audio signal.|| Note:| - This algorithm is outdated. For beat tracking it is recommended to use| RhythmExtractor2013 algorithm found to perform better than NoveltyCurve with| BpmHistogram in evaluations.| - The "frameRate" parameter refers to the frame rate at which the novelty| curve has been computed. It is equal to the audio sampling rate divided by| the hop size at which the signal was processed.| - Although the algorithm tries to find beats that fit the mean BPM the best,| the tempo is not assumed to be constant unless specified in the corresponding| parameter. For this reason and if tempo differs too much from frame to frame,| there may be phase discontinuities when constructing the sinusoid which can| yield to too many ticks. One can recursively run this algorithm on the| sinusoid output until the ticks stabilize. At this point it may be useful to| infer a specific BPM and set the constant tempo parameter to true.| - Another useful trick is to run the algorithm one time to get an estimation| of the mean BPM and re-run it again with a "frameSize" parameter set to a| multiple of the mean BPM.|| Quality: outdated (use RhythmExtractor2013 instead, still this algorithm| might be useful when working with other onset detection functions apart from| NoveltyCurve)|| References:| [1] P. Grosche and M. Müller, "A mid-level representation for capturing| dominant tempo and pulse information in music recordings," in| International Society for Music Information Retrieval Conference| (ISMIR’09), 2009, pp. 189–194.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm ana...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BpmHistogramDescriptors = class Algo(Algorithm)| BpmHistogramDescriptors||| Inputs:|| [vector_real] bpmIntervals - the list of bpm intervals [s]||| Outputs:|| [real] firstPeakBPM - value for the highest peak [bpm]| [real] firstPeakWeight - weight of the highest peak| [real] firstPeakSpread - spread of the highest peak| [real] secondPeakBPM - value for the second highest peak [bpm]| [real] secondPeakWeight - weight of the second highest peak| [real] secondPeakSpread - spread of the second highest peak| [vector_real] histogram - bpm histogram [bpm]||| Description:|| This algorithm computes beats per minute histogram and its statistics for the| highest and second highest peak.| Note: histogram vector contains occurance frequency for each bpm value, 0-th| element corresponds to 0 bpm value.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).BpmRubato = class Algo(Algorithm)| BpmRubato||| Inputs:|| [vector_real] beats - list of detected beat ticks [s]||| Outputs:|| [vector_real] rubatoStart - list of timestamps where the start of a rubato region was detected [s]| [vector_real] rubatoStop - list of timestamps where the end of a rubato region was detected [s]| [integer] rubatoNumber - number of detected rubato regions||| Parameters:|| longRegionsPruningTime:| real ∈ [0,inf) (default = 20)| time for the longest constant tempo region inside a rubato region [s]|| shortRegionsMergingTime:| real ∈ [0,inf) (default = 4)| time for the shortest constant tempo region from one tempo region to| another [s]|| tolerance:| real ∈ [0,1] (default = 0.0799999982119)| minimum tempo deviation to look for||| Description:|| This algorithm extracts the locations of large tempo changes from a list of| beat ticks.|| An exception is thrown if the input beats are not in ascending order and/or| if the input beats contain duplicate values.|| Quality: experimental (non-reliable, poor accuracy).|| References:| [1] Tempo Rubato - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Rubato|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm ext...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CartesianToPolar = class Algo(Algorithm)| CartesianToPolar||| Inputs:|| [vector_complex] complex - the complex input vector||| Outputs:|| [vector_real] magnitude - the magnitude vector| [vector_real] phase - the phase vector||| Description:|| This algorithm converts an array of complex numbers from cartesian to polar| form. It uses the Euler formula:| z = x + i*y = |z|(cos(α) + i sin(α))| where x = Real part, y = Imaginary part,| and |z| = modulus = magnitude, α = phase in (-pi,pi]|| It returns the magnitude and the phase as 2 separate vectors.|| References:| [1] Polar Coordinates -- from Wolfram MathWorld,| http://mathworld.wolfram.com/PolarCoordinates.html|| [2] Polar coordinate system - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Polar_coordinates|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Math', 'description': 'This algorithm conve...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CentralMoments = class Algo(Algorithm)| CentralMoments||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] centralMoments - the central moments of the input array||| Parameters:|| mode:| string ∈ {pdf,sample} (default = "pdf")| compute central moments considering array values as a probability density| function over array index or as sample points of a distribution|| range:| real ∈ (0,inf) (default = 1)| the range of the input array, used for normalizing the results in the 'pdf'| mode||| Description:|| This algorithm extracts the 0th, 1st, 2nd, 3rd and 4th central moments of an| array. It returns a 5-tuple in which the index corresponds to the order of| the moment.|| Central moments cannot be computed on arrays which size is less than 2, in| which case an exception is thrown.|| Note: the 'mode' parameter defines whether to treat array values as a| probability distribution function (pdf) or as sample points of a distribution| (sample).|| References:| [1] Sample Central Moment -- from Wolfram MathWorld,| http://mathworld.wolfram.com/SampleCentralMoment.html|| [2] Central Moment - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Central_moment|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Centroid = class Algo(Algorithm)| Centroid||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] centroid - the centroid of the array||| Parameters:|| range:| real ∈ (0,inf) (default = 1)| the range of the input array, used for normalizing the results||| Description:|| This algorithm computes the centroid of an array. The centroid is normalized| to a specified range. This algorithm can be used to compute spectral centroid| or temporal centroid.|| The spectral centroid is a measure that indicates where the "center of mass"| of the spectrum is. Perceptually, it has a robust connection with the| impression of "brightness" of a sound, and therefore is used to characterise| musical timbre. It is calculated as the weighted mean of the frequencies| present in the signal, with their magnitudes as the weights.|| The temporal centroid is the point in time in a signal that is a temporal| balancing point of the sound event energy. It can be computed from the| envelope of the signal across audio samples [3] (see Envelope algorithm) or| over the RMS level of signal across frames [4] (see RMS algorithm).|| Note:| - For a spectral centroid [hz], frequency range should be equal to| samplerate/2| - For a temporal envelope centroid [s], range should be equal to| (audio_size_in_samples-1) / samplerate| - Exceptions are thrown when input array contains less than 2 elements.|| References:| [1] Function Centroid -- from Wolfram MathWorld,| http://mathworld.wolfram.com/FunctionCentroid.html| [2] Spectral centroid - Wikipedia, the free encyclopedia,| https://en.wikipedia.org/wiki/Spectral_centroid| [3] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004.| [4] Klapuri, A., & Davy, M. (Eds.). (2007). Signal processing methods for| music transcription. Springer Science & Business Media.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ChordsDescriptors = class Algo(Algorithm)| ChordsDescriptors||| Inputs:|| [vector_string] chords - the chord progression| [string] key - the key of the whole song, from A to G| [string] scale - the scale of the whole song (major or minor)||| Outputs:|| [vector_real] chordsHistogram - the normalized histogram of chords| [real] chordsNumberRate - the ratio of different chords from the total number of chords in the progression| [real] chordsChangesRate - the rate at which chords change in the progression| [string] chordsKey - the most frequent chord of the progression| [string] chordsScale - the scale of the most frequent chord of the progression (either 'major' or 'minor')||| Description:|| Given a chord progression this algorithm describes it by means of key, scale,| histogram, and rate of change.| Note:| - chordsHistogram indexes follow the circle of fifths order, while being| shifted to the input key and scale| - key and scale are taken from the most frequent chord. In the case where| multiple chords are equally frequent, the chord is hierarchically chosen from| the circle of fifths.| - chords should follow this name convention `<A-G>[<#/b><m>]` (i.e. C, C#| or C#m are valid chords). Chord names not fitting this convention will throw| an exception.|| Input chords vector may not be empty, otherwise an exception is thrown.|| References:| [1] Chord progression - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Chord_progression|| [2] Circle of fifths - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Circle_of_fifths|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'Given a chord progr...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ChordsDetection = class Algo(Algorithm)| ChordsDetection||| Inputs:|| [vector_vector_real] pcp - the pitch class profile from which to detect the chord||| Outputs:|| [vector_string] chords - the resulting chords, from A to G| [vector_real] strength - the strength of the chord||| Parameters:|| hopSize:| integer ∈ (0,inf) (default = 2048)| the hop size with which the input PCPs were computed|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| windowSize:| real ∈ (0,inf) (default = 2)| the size of the window on which to estimate the chords [s]||| Description:|| This algorithm estimates chords given an input sequence of harmonic pitch| class profiles (HPCPs). It finds the best matching major or minor triad and| outputs the result as a string (e.g. A#, Bm, G#m, C). This algorithm uses the| Sharp versions of each Flatted note (i.e. Bb -> A#).|| Note:| - The algorithm assumes that the sequence of the input HPCP frames has been| computed with framesize = 2*hopsize| - The algorithm estimates a sequence of chord values corresponding to the| input HPCP frames (one chord value for each frame, estimated using a temporal| window of HPCPs centered at that frame).|| Quality: experimental (prone to errors, algorithm needs improvement)|| References:| [1] E. Gómez, "Tonal Description of Polyphonic Audio for Music Content| Processing," INFORMS Journal on Computing, vol. 18, no. 3, pp. 294–304,| 2006.|| [2] D. Temperley, "What's key for key? The Krumhansl-Schmuckler| key-finding algorithm reconsidered", Music Perception vol. 17, no. 1,| pp. 65-100, 1999.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ChordsDetectionBeats = class Algo(Algorithm)| ChordsDetectionBeats||| Inputs:|| [vector_vector_real] pcp - the pitch class profile from which to detect the chord| [vector_real] ticks - the list of beat positions (in seconds)||| Outputs:|| [vector_string] chords - the resulting chords, from A to G| [vector_real] strength - the strength of the chords||| Parameters:|| chromaPick:| string ∈ {starting_beat,interbeat_median} (default = "interbeat_median")| method of calculating singleton chroma for interbeat interval|| hopSize:| integer ∈ (0,inf) (default = 2048)| the hop size with which the input PCPs were computed|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm estimates chords using pitch profile classes on segments| between beats. It is similar to ChordsDetection algorithm, but the chords are| estimated on audio segments between each pair of consecutive beats. For each| segment the estimation is done based on a chroma (HPCP) vector characterizing| it, which can be computed by two methods:| - 'interbeat_median', each resulting chroma vector component is a median of| all the component values in the segment| - 'starting_beat', chroma vector is sampled from the start of the segment| (that is, its starting beat position) using its first frame. It makes sense| if chroma is preliminary smoothed.|| Quality: experimental (algorithm needs evaluation)|| References:| [1] E. Gómez, "Tonal Description of Polyphonic Audio for Music Content| Processing," INFORMS Journal on Computing, vol. 18, no. 3, pp. 294–304,| 2006.|| [2] D. Temperley, "What's key for key? The Krumhansl-Schmuckler| key-finding algorithm reconsidered", Music Perception vol. 17, no. 1,| pp. 65-100, 1999.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ChromaCrossSimilarity = class Algo(Algorithm)| ChromaCrossSimilarity||| Inputs:|| [vector_vector_real] queryFeature - frame-wise chromagram of the query song (e.g., a HPCP)| [vector_vector_real] referenceFeature - frame-wise chromagram of the reference song (e.g., a HPCP)||| Outputs:|| [vector_vector_real] csm - 2D binary cross-similarity matrix of the query and reference features||| Parameters:|| binarizePercentile:| real ∈ [0,1] (default = 0.0949999988079)| maximum percent of distance values to consider as similar in each row and| each column|| frameStackSize:| integer ∈ [0,inf) (default = 9)| number of input frames to stack together and treat as a feature vector for| similarity computation. Choose 'frameStackSize=1' to use the original input| frames without stacking|| frameStackStride:| integer ∈ [1,inf) (default = 1)| stride size to form a stack of frames (e.g., 'frameStackStride'=1 to use| consecutive frames; 'frameStackStride'=2 for using every second frame)|| noti:| integer ∈ [0, inf) (default = 12)| number of circular shifts to be checked for Optimal Transposition Index [1]|| oti:| bool ∈ {true,false} (default = true)| whether to transpose the key of the reference song to the query song by| Optimal Transposition Index [1]|| otiBinary:| bool ∈ {true,false} (default = false)| whether to use the OTI-based chroma binary similarity method [3]|| streaming:| bool ∈ {true,false} (default = false)| whether to accumulate the input 'queryFeature' in the euclidean similarity| matrix calculation on each compute() method call||| Description:|| This algorithm computes a binary cross similarity matrix from two chromagam| feature vectors of a query and reference song.|| With default parameters, this algorithm computes cross-similarity of two| given input chromagrams as described in [2].|| Use HPCP algorithm for computing the chromagram with default parameters of| this algorithm for the best results.|| If parameter 'oti=True', the algorithm transpose the reference song| chromagram by optimal transposition index as described in [1].|| If parameter 'otiBinary=True', the algorithm computes the binary| cross-similarity matrix based on optimal transposition index between each| feature pairs instead of euclidean distance as described in [3].|| The input chromagram should be in the shape (n_frames, numbins), where| 'n_frames' is number of frames and 'numbins' for the number of bins in the| chromagram. An exception is thrown otherwise.|| An exception is also thrown if either one of the input chromagrams are empty.|| While param 'streaming=True', the algorithm accumulates the input| 'queryFeature' in the pairwise similarity matrix calculation on each call of| compute() method. You can reset it using the reset() method.|| References:|| [1] Serra, J., Gómez, E., & Herrera, P. (2008). Transposing chroma| representations to a common key, IEEE Conference on The Use of Symbols to| Represent Music and Multimedia Objects.|| [2] Serra, J., Serra, X., & Andrzejak, R. G. (2009). Cross recurrence| quantification for cover song identification.New Journal of Physics.|| [3] Serra, Joan, et al. Chroma binary similarity and local alignment applied| to cover song identification. IEEE Transactions on Audio, Speech, and| Language Processing 16.6 (2008).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Music Similarity', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Chromagram = class Algo(Algorithm)| Chromagram||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] chromagram - the magnitude constant-Q chromagram||| Parameters:|| binsPerOctave:| integer ∈ [1,inf) (default = 12)| number of bins per octave|| minFrequency:| real ∈ [1,inf) (default = 32.7000007629)| minimum frequency [Hz]|| minimumKernelSize:| integer ∈ [2,inf) (default = 4)| minimum size allowed for frequency kernels|| normalizeType:| string ∈ {none,unit_sum,unit_max} (default = "unit_max")| normalize type|| numberBins:| integer ∈ [1,inf) (default = 84)| number of frequency bins, starting at minFrequency|| sampleRate:| real ∈ [0,inf) (default = 44100)| FFT sampling rate [Hz]|| scale:| real ∈ [0,inf) (default = 1)| filters scale. Larger values use longer windows|| threshold:| real ∈ [0,1) (default = 0.00999999977648)| bins whose magnitude is below this quantile are discarded|| windowType:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'|| zeroPhase:| bool ∈ {true,false} (default = true)| a boolean value that enables zero-phase windowing. Input audio frames| should be windowed with the same phase mode||| Description:|| This algorithm computes the Constant-Q chromagram using FFT. See ConstantQ| algorithm for more details.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Chromaprinter = class Algo(Algorithm)| Chromaprinter||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [string] fingerprint - the chromaprint as a base64-encoded string||| Parameters:|| maxLength:| real ∈ [0,inf) (default = 0)| use the first 'maxLength' seconds to compute the chromaprint. 0 to use the| full audio length [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the input audio sampling rate [Hz]||| Description:|| This algorithm computes the fingerprint of the input signal using Chromaprint| algorithm. It is a wrapper of the Chromaprint library [1,2]. The chromaprints| are returned as base64-encoded strings.|| References:| [1] Chromaprint -- from the Acousticid project,| https://acoustid.org/chromaprint|| [2] https://github.com/acoustid/chromaprint|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Fingerprinting', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ClickDetector = class Algo(Algorithm)| ClickDetector||| Inputs:|| [vector_real] frame - the input frame (must be non-empty)||| Outputs:|| [vector_real] starts - starting indexes of the clicks| [vector_real] ends - ending indexes of the clicks||| Parameters:|| detectionThreshold:| real ∈ (-inf,inf) (default = 30)| 'detectionThreshold' the threshold is based on the instant power of the| noisy excitation signal plus detectionThreshold dBs|| frameSize:| integer ∈ (0,inf) (default = 512)| the expected size of the input audio signal (this is an optional parameter| to optimize memory allocation)|| hopSize:| integer ∈ (0,inf) (default = 256)| hop size used for the analysis. This parameter must be set correctly as it| cannot be obtained from the input data|| order:| integer ∈ [1,inf) (default = 12)| scalar giving the number of LPCs to use|| powerEstimationThreshold:| integer ∈ (0,inf) (default = 10)| the noisy excitation is clipped to 'powerEstimationThreshold' times its| median.|| sampleRate:| real ∈ (0,inf) (default = 44100)| sample rate used for the analysis|| silenceThreshold:| integer ∈ (-inf,0) (default = -50)| threshold to skip silent frames||| Description:|| This algorithm detects the locations of impulsive noises (clicks and pops) on| the input audio frame. It relies on LPC coefficients to inverse-filter the| audio in order to attenuate the stationary part and enhance the prediction| error (or excitation noise)[1]. After this, a matched filter is used to| further enhance the impulsive peaks. The detection threshold is obtained from| a robust estimate of the excitation noise power [2] plus a parametric gain| value.|| References:| [1] Vaseghi, S. V., & Rayner, P. J. W. (1990). Detection and suppression of| impulsive noise in speech communication systems. IEE Proceedings I| (Communications, Speech and Vision), 137(1), 38-46.| [2] Vaseghi, S. V. (2008). Advanced digital signal processing and noise| reduction. John Wiley & Sons. Page 355|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Clipper = class Algo(Algorithm)| Clipper||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the output signal with the added noise||| Parameters:|| max:| real ∈ (-inf,inf) (default = 1)| the maximum value above which the signal will be clipped|| min:| real ∈ (-inf,inf) (default = -1)| the minimum value below which the signal will be clipped||| Description:|| This algorithm clips the input signal to fit its values into a specified| interval.|| References:| [1] Clipping - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Clipping_(audio)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ConstantQ = class Algo(Algorithm)| ConstantQ||| Inputs:|| [vector_real] frame - the windowed input audio frame||| Outputs:|| [vector_complex] constantq - the Constant Q transform||| Parameters:|| binsPerOctave:| integer ∈ [1,inf) (default = 12)| number of bins per octave|| minFrequency:| real ∈ [1,inf) (default = 32.7000007629)| minimum frequency [Hz]|| minimumKernelSize:| integer ∈ [2,inf) (default = 4)| minimum size allowed for frequency kernels|| numberBins:| integer ∈ [1,inf) (default = 84)| number of frequency bins, starting at minFrequency|| sampleRate:| real ∈ [0,inf) (default = 44100)| FFT sampling rate [Hz]|| scale:| real ∈ [0,inf) (default = 1)| filters scale. Larger values use longer windows|| threshold:| real ∈ [0,1) (default = 0.00999999977648)| bins whose magnitude is below this quantile are discarded|| windowType:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'|| zeroPhase:| bool ∈ {true,false} (default = true)| a boolean value that enables zero-phase windowing. Input audio frames| should be windowed with the same phase mode||| Description:|| This algorithm computes Constant Q Transform using the FFT for fast| calculation. It transforms a windowed audio frame into the log frequency| domain.|| References:| [1] Constant Q transform - Wikipedia, the free encyclopedia,| https://en.wikipedia.org/wiki/Constant_Q_transform| [2] Brown, J. C., & Puckette, M. S. (1992). An efficient algorithm for the| calculation of a constant Q transform. The Journal of the Acoustical| Society| of America, 92(5), 2698-2701.| [3] Schörkhuber, C., & Klapuri, A. (2010). Constant-Q transform toolbox| for| music processing. In 7th Sound and Music Computing Conference, Barcelona,| Spain (pp. 3-64).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CoverSongSimilarity = class Algo(Algorithm)| CoverSongSimilarity||| Inputs:|| [vector_vector_real] inputArray - a 2D binary cross-similarity matrix between two audio chroma vectors (query vs reference song) (refer 'ChromaCrossSimilarity' algorithm').||| Outputs:|| [vector_vector_real] scoreMatrix - a 2D smith-waterman alignment score matrix from the input binary cross-similarity matrix| [real] distance - cover song similarity distance between the query and reference song from the input similarity matrix. Either 'asymmetric' (as described in [2]) or 'symmetric' (maximum score in the alignment score matrix).||| Parameters:|| alignmentType:| string ∈ {serra09,chen17} (default = "serra09")| choose either one of the given local-alignment constraints for| smith-waterman algorithm as described in [2] or [3] respectively.|| disExtension:| real ∈ [0,inf) (default = 0.5)| penalty for disruption extension|| disOnset:| real ∈ [0,inf) (default = 0.5)| penalty for disruption onset|| distanceType:| string ∈ {asymmetric,symmetric} (default = "asymmetric")| choose the type of distance. By default the algorithm outputs a asymmetric| disctance which is obtained by normalising the maximum score in the| alignment score matrix with length of reference song||| Description:|| This algorithm computes a cover song similiarity measure from a binary cross| similarity matrix input between two chroma vectors of a query and reference| song using various alignment constraints of smith-waterman local-alignment| algorithm.|| This algorithm expects to recieve the binary similarity matrix input from| essentia 'ChromaCrossSimilarity' algorithm or essentia| 'CrossSimilarityMatrix' with parameter 'binarize=True'.|| The algorithm provides two different allignment contraints for computing the| smith-waterman score matrix (check references).|| Exceptions are thrown if the input similarity matrix is not binary or empty.|| References:|| [1] Smith-Waterman algorithm (Wikipedia,| https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm).|| [2] Serra, J., Serra, X., & Andrzejak, R. G. (2009). Cross recurrence| quantification for cover song identification.New Journal of Physics.|| [3] Chen, N., Li, W., & Xiao, H. (2017). Fusing similarity functions for| cover song identification. Multimedia Tools and Applications.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Music Similarity', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Crest = class Algo(Algorithm)| Crest||| Inputs:|| [vector_real] array - the input array (cannot contain negative values, and must be non-empty)||| Outputs:|| [real] crest - the crest of the input array||| Description:|| This algorithm computes the crest of an array. The crest is defined as the| ratio between the maximum value and the arithmetic mean of an array.| Typically it is used on the magnitude spectrum.|| Crest cannot be computed neither on empty arrays nor arrays which contain| negative values. In such cases, exceptions will be thrown.|| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CrossCorrelation = class Algo(Algorithm)| CrossCorrelation||| Inputs:|| [vector_real] arrayX - the first input array| [vector_real] arrayY - the second input array||| Outputs:|| [vector_real] crossCorrelation - the cross-correlation vector between the two input arrays (its size is equal to maxLag - minLag + 1)||| Parameters:|| maxLag:| integer ∈ (-inf,inf) (default = 1)| the maximum lag to be computed between the two vectors|| minLag:| integer ∈ (-inf,inf) (default = 0)| the minimum lag to be computed between the two vectors||| Description:|| This algorithm computes the cross-correlation vector of two signals. It| accepts 2 parameters, minLag and maxLag which define the range of the| computation of the innerproduct.|| An exception is thrown if "minLag" is larger than "maxLag". An exception is| also thrown if the input vectors are empty.|| References:| [1] Cross-correlation - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Cross-correlation|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CrossSimilarityMatrix = class Algo(Algorithm)| CrossSimilarityMatrix||| Inputs:|| [vector_vector_real] queryFeature - input frame features of the query song (e.g., a chromagram)| [vector_vector_real] referenceFeature - input frame features of the reference song (e.g., a chromagram)||| Outputs:|| [vector_vector_real] csm - 2D cross-similarity matrix of two input frame sequences (query vs reference)||| Parameters:|| binarize:| bool ∈ {true,false} (default = false)| whether to binarize the euclidean cross-similarity matrix|| binarizePercentile:| real ∈ [0,1] (default = 0.0949999988079)| maximum percent of distance values to consider as similar in each row and| each column|| frameStackSize:| integer ∈ [0,inf) (default = 1)| number of input frames to stack together and treat as a feature vector for| similarity computation. Choose 'frameStackSize=1' to use the original input| frames without stacking|| frameStackStride:| integer ∈ [1,inf) (default = 1)| stride size to form a stack of frames (e.g., 'frameStackStride'=1 to use| consecutive frames; 'frameStackStride'=2 for using every second frame)||| Description:|| This algorithm computes a euclidean cross-similarity matrix of two sequences| of frame features. Similarity values can be optionally binarized|| The default parameters for binarizing are optimized according to [1] for| cover song identification using chroma features.|| The input feature arrays are vectors of frames of features in the shape| (n_frames, n_features), where 'n_frames' is the number frames, 'n_features'| is the number of frame features.|| An exception is also thrown if either one of the input feature arrays are| empty or if the output similarity matrix is empty.|| References:|| [1] Serra, J., Serra, X., & Andrzejak, R. G. (2009). Cross recurrence| quantification for cover song identification. New Journal of Physics.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Music Similarity', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).CubicSpline = class Algo(Algorithm)| CubicSpline||| Inputs:|| [real] x - the input coordinate (x-axis)||| Outputs:|| [real] y - the value of the spline at x| [real] dy - the first derivative of the spline at x| [real] ddy - the second derivative of the spline at x||| Parameters:|| leftBoundaryFlag:| integer ∈ {0,1,2} (default = 0)| type of boundary condition for the left boundary|| leftBoundaryValue:| real ∈ (-inf,inf) (default = 0)| the value to be used in the left boundary, when leftBoundaryFlag is 1 or 2|| rightBoundaryFlag:| integer ∈ {0,1,2} (default = 0)| type of boundary condition for the right boundary|| rightBoundaryValue:| real ∈ (-inf,inf) (default = 0)| the value to be used in the right boundary, when rightBoundaryFlag is 1 or| 2|| xPoints:| vector_real (default = [0, 1])| the x-coordinates where data is specified (the points must be arranged in| ascending order and cannot contain duplicates)|| yPoints:| vector_real (default = [0, 1])| the y-coordinates to be interpolated (i.e. the known data)||| Description:|| Computes the second derivatives of a piecewise cubic spline.| The input value, i.e. the point at which the spline is to be evaluated| typically should be between xPoints[0] and xPoints[size-1]. If the value lies| outside this range, extrapolation is used.| Regarding [left/right] boundary condition flag parameters:| - 0: the cubic spline should be a quadratic over the first interval| - 1: the first derivative at the [left/right] endpoint should be| [left/right]BoundaryFlag| - 2: the second derivative at the [left/right] endpoint should be| [left/right]BoundaryFlag| References:| [1] Spline interpolation - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Spline_interpolation|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'Computes the sec...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DCRemoval = class Algo(Algorithm)| DCRemoval||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the filtered signal, with the DC component removed||| Parameters:|| cutoffFrequency:| real ∈ (0,inf) (default = 40)| the cutoff frequency for the filter [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm removes the DC offset from a signal using a 1st order IIR| highpass filter. Because of its dependence on IIR, IIR's requirements are| inherited.|| References:| [1] Smith, J.O. Introduction to Digital Filters with Audio Applications,| http://ccrma-www.stanford.edu/~jos/filters/DC_Blocker.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm re...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DCT = class Algo(Algorithm)| DCT||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] dct - the discrete cosine transform of the input array||| Parameters:|| dctType:| integer ∈ [2,3] (default = 2)| the DCT type|| inputSize:| integer ∈ [1,inf) (default = 10)| the size of the input array|| liftering:| integer ∈ [0,inf) (default = 0)| the liftering coefficient. Use '0' to bypass it|| outputSize:| integer ∈ [1,inf) (default = 10)| the number of output coefficients||| Description:|| This algorithm computes the Discrete Cosine Transform of an array.| It uses the DCT-II form, with the 1/sqrt(2) scaling factor for the first| coefficient.|| Note: The 'inputSize' parameter is only used as an optimization when the| algorithm is configured. The DCT will automatically adjust to the size of any| input.|| References:| [1] Discrete cosine transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Discrete_cosine_transform|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Danceability = class Algo(Algorithm)| Danceability||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] danceability - the danceability value. Normal values range from 0 to ~3. The higher, the more danceable.| [vector_real] dfa - the DFA exponent vector for considered segment length (tau) values||| Parameters:|| maxTau:| real ∈ (0,inf) (default = 8800)| maximum segment length to consider [ms]|| minTau:| real ∈ (0,inf) (default = 310)| minimum segment length to consider [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| tauMultiplier:| real ∈ [1,inf) (default = 1.10000002384)| multiplier to increment from min to max tau||| Description:|| This algorithm estimates danceability of a given audio signal. The algorithm| is derived from Detrended Fluctuation Analysis (DFA) described in [1]. The| parameters minTau and maxTau are used to define the range of time over which| DFA will be performed. The output of this algorithm is the danceability of| the audio signal. These values usually range from 0 to 3 (higher values| meaning more danceable).|| Exception is thrown when minTau is greater than maxTau.|| References:| [1] Streich, S. and Herrera, P., Detrended Fluctuation Analysis of Music| Signals: Danceability Estimation and further Semantic Characterization,| Proceedings of the AES 118th Convention, Barcelona, Spain, 2005|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Decrease = class Algo(Algorithm)| Decrease||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] decrease - the decrease of the input array||| Parameters:|| range:| real ∈ (-inf,inf) (default = 1)| the range of the input array, used for normalizing the results||| Description:|| This algorithm computes the decrease of an array defined as the linear| regression coefficient. The range parameter is used to normalize the result.| For a spectral centroid, the range should be equal to Nyquist and for an| audio centroid the range should be equal to (audiosize - 1) / samplerate.| The size of the input array must be at least two elements for "decrease" to| be computed, otherwise an exception is thrown.| References:| [1] Least Squares Fitting -- from Wolfram MathWorld,| http://mathworld.wolfram.com/LeastSquaresFitting.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Derivative = class Algo(Algorithm)| Derivative||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the derivative of the input signal||| Description:|| This algorithm returns the first-order derivative of an input signal. That| is, for each input value it returns the value minus the previous one.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm r...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DerivativeSFX = class Algo(Algorithm)| DerivativeSFX||| Inputs:|| [vector_real] envelope - the envelope of the signal||| Outputs:|| [real] derAvAfterMax - the weighted average of the derivative after the maximum amplitude| [real] maxDerBeforeMax - the maximum derivative before the maximum amplitude||| Description:|| This algorithm computes two descriptors that are based on the derivative of a| signal envelope.|| The first descriptor is calculated after the maximum value of the input| signal occurred. It is the average of the signal's derivative weighted by its| amplitude. This coefficient helps discriminating impulsive sounds, which have| a steep release phase, from non-impulsive sounds. The smaller the value the| more impulsive.|| The second descriptor is the maximum derivative, before the maximum value of| the input signal occurred. This coefficient helps discriminating sounds that| have a smooth attack phase, and therefore a smaller value than sounds with a| fast attack.|| This algorithm is meant to be fed by the outputs of the Envelope algorithm.| If used in streaming mode, RealAccumulator should be connected in between.| An exception is thrown if the input signal is empty.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DiscontinuityDetector = class Algo(Algorithm)| DiscontinuityDetector||| Inputs:|| [vector_real] frame - the input frame (must be non-empty)||| Outputs:|| [vector_real] discontinuityLocations - the index of the detected discontinuities (if any)| [vector_real] discontinuityAmplitudes - the peak values of the prediction error for the discontinuities (if any)||| Parameters:|| detectionThreshold:| real ∈ [1,inf) (default = 8)| 'detectionThreshold' times the standard deviation plus the median of the| frame is used as detection threshold|| energyThreshold:| real ∈ (-inf,inf) (default = -60)| threshold in dB to detect silent subframes|| frameSize:| integer ∈ (0,inf) (default = 512)| the expected size of the input audio signal (this is an optional parameter| to optimize memory allocation)|| hopSize:| integer ∈ [0,inf) (default = 256)| hop size used for the analysis. This parameter must be set correctly as it| cannot be obtained from the input data|| kernelSize:| integer ∈ [1,inf) (default = 7)| scalar giving the size of the median filter window. Must be odd|| order:| integer ∈ [1,inf) (default = 3)| scalar giving the number of LPCs to use|| silenceThreshold:| integer ∈ (-inf,0) (default = -50)| threshold to skip silent frames|| subFrameSize:| integer ∈ [1,inf) (default = 32)| size of the window used to compute silent subframes||| Description:|| This algorithm uses LPC and some heuristics to detect discontinuities in an| audio signal. [1].|| References:| [1] Mühlbauer, R. (2010). Automatic Audio Defect Detection.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Dissonance = class Algo(Algorithm)| Dissonance||| Inputs:|| [vector_real] frequencies - the frequencies of the spectral peaks (must be sorted by frequency)| [vector_real] magnitudes - the magnitudes of the spectral peaks (must be sorted by frequency||| Outputs:|| [real] dissonance - the dissonance of the audio signal (0 meaning completely consonant, and 1 meaning completely dissonant)||| Description:|| This algorithm computes the sensory dissonance of an audio signal given its| spectral peaks. Sensory dissonance (to be distinguished from musical or| theoretical dissonance) measures perceptual roughness of the sound and is| based on the roughness of its spectral peaks. Given the spectral peaks, the| algorithm estimates total dissonance by summing up the normalized dissonance| values for each pair of peaks. These values are computed using dissonance| curves, which define dissonace between two spectral peaks according to their| frequency and amplitude relations. The dissonance curves are based on| perceptual experiments conducted in [1].| Exceptions are thrown when the size of the input vectors are not equal or if| input frequencies are not ordered ascendantly| References:| [1] R. Plomp and W. J. M. Levelt, "Tonal Consonance and Critical| Bandwidth," The Journal of the Acoustical Society of America, vol. 38,| no. 4, pp. 548–560, 1965.|| [2] Critical Band - Handbook for Acoustic Ecology| http://www.sfu.ca/sonic-studio/handbook/Critical_Band.html|| [3] Bark Scale - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Bark_scale|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DistributionShape = class Algo(Algorithm)| DistributionShape||| Inputs:|| [vector_real] centralMoments - the central moments of a distribution||| Outputs:|| [real] spread - the spread (variance) of the distribution| [real] skewness - the skewness of the distribution| [real] kurtosis - the kurtosis of the distribution||| Description:|| This algorithm computes the spread (variance), skewness and kurtosis of an| array given its central moments. The extracted features are good indicators| of the shape of the distribution. For the required input see CentralMoments| algorithm.| The size of the input array must be at least 5. An exception will be thrown| otherwise.|| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004.|| [2] Variance - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Variance|| [3] Skewness - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Skewness|| [4] Kurtosis - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Kurtosis|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Duration = class Algo(Algorithm)| Duration||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] duration - the duration of the signal [s]||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm outputs the total duration of an audio signal.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Duration/silence', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).DynamicComplexity = class Algo(Algorithm)| DynamicComplexity||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [real] dynamicComplexity - the dynamic complexity coefficient| [real] loudness - an estimate of the loudness [dB]||| Parameters:|| frameSize:| real ∈ (0,inf) (default = 0.20000000298)| the frame size [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the dynamic complexity defined as the average| absolute deviation from the global loudness level estimate on the dB scale.| It is related to the dynamic range and to the amount of fluctuation in| loudness present in a recording. Silence at the beginning and at the end of a| track are ignored in the computation in order not to deteriorate the results.|| References:| [1] S. Streich, Music complexity: a multi-faceted description of audio| content, UPF, Barcelona, Spain, 2007.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ERBBands = class Algo(Algorithm)| ERBBands||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energies/magnitudes of each band||| Parameters:|| highFrequencyBound:| real ∈ [0,inf) (default = 22050)| an upper-bound limit for the frequencies to be included in the bands|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of the spectrum|| lowFrequencyBound:| real ∈ [0,inf) (default = 50)| a lower-bound limit for the frequencies to be included in the bands|| numberBands:| integer ∈ (1,inf) (default = 40)| the number of output bands|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum|| width:| real ∈ (0,inf) (default = 1)| filter width with respect to ERB||| Description:|| This algorithm computes energies/magnitudes in ERB bands of a spectrum. The| Equivalent Rectangular Bandwidth (ERB) scale is used. The algorithm applies a| frequency domain filterbank using gammatone filters. Adapted from matlab code| in: D. P. W. Ellis (2009). 'Gammatone-like spectrograms', web resource [1].|| References:| [1] http://www.ee.columbia.edu/~dpwe/resources/matlab/gammatonegram/|| [2] B. C. Moore and B. R. Glasberg, "Suggested formulae for calculating| auditory-filter bandwidths and excitation patterns," Journal of the| Acoustical Society of America, vol. 74, no. 3, pp. 750–753, 1983.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EasyLoader = class Algo(Algorithm)| EasyLoader||| Outputs:|| [vector_real] audio - the audio signal||| Parameters:|| audioStream:| integer ∈ [0,inf) (default = 0)| audio stream index to be loaded. Other streams are no taken into account| (e.g. if stream 0 is video and 1 is audio use index 0 to access it.)|| downmix:| string ∈ {left,right,mix} (default = "mix")| the mixing type for stereo files|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice to be extracted [s]|| filename:| string| the name of the file from which to read|| replayGain:| real ∈ (-inf,inf) (default = -6)| the value of the replayGain that should be used to normalize the signal| [dB]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the output sampling rate [Hz]|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice to be extracted [s]||| Description:|| This algorithm loads the raw audio data from an audio file, downmixes it to| mono and normalizes using replayGain. The audio is resampled in case the| given sampling rate does not match the sampling rate of the input signal and| is normalized by the given replayGain value.|| This algorithm uses MonoLoader and therefore inherits all of its input| requirements and exceptions.|| References:| [1] Replay Gain - A Proposed Standard,| http://replaygain.hydrogenaudio.org|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EffectiveDuration = class Algo(Algorithm)| EffectiveDuration||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] effectiveDuration - the effective duration of the signal [s]||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| thresholdRatio:| real ∈ [0,1] (default = 0.40000000596)| the ratio of the envelope maximum to be used as the threshold||| Description:|| This algorithm computes the effective duration of an envelope signal. The| effective duration is a measure of the time the signal is perceptually| meaningful. This is approximated by the time the envelope is above or equal| to a given threshold and is above the -90db noise floor. This measure allows| to distinguish percussive sounds from sustained sounds but depends on the| signal length.| By default, this algorithm uses 40% of the envelope maximum as the threshold| which is suited for short sounds. Note, that the 0% thresold corresponds to| the duration of signal above -90db noise floor, while the 100% thresold| corresponds to the number of times the envelope takes its maximum value.| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Duration/silence', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Energy = class Algo(Algorithm)| Energy||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] energy - the energy of the input array||| Description:|| This algorithm computes the energy of an array.|| The input array should not be empty or an exception will be thrown.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EnergyBand = class Algo(Algorithm)| EnergyBand||| Inputs:|| [vector_real] spectrum - the input frequency spectrum||| Outputs:|| [real] energyBand - the energy in the frequency band||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]|| startCutoffFrequency:| real ∈ [0,inf) (default = 0)| the start frequency from which to sum the energy [Hz]|| stopCutoffFrequency:| real ∈ (0,inf) (default = 100)| the stop frequency to which to sum the energy [Hz]||| Description:|| This algorithm computes energy in a given frequency band of a spectrum| including both start and stop cutoff frequencies.| Note that exceptions will be thrown when input spectrum is empty and if| startCutoffFrequency is greater than stopCutoffFrequency.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EnergyBandRatio = class Algo(Algorithm)| EnergyBandRatio||| Inputs:|| [vector_real] spectrum - the input audio spectrum||| Outputs:|| [real] energyBandRatio - the energy ratio of the specified band over the total energy||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| startFrequency:| real ∈ [0,inf) (default = 0)| the frequency from which to start summing the energy [Hz]|| stopFrequency:| real ∈ [0,inf) (default = 100)| the frequency up to which to sum the energy [Hz]||| Description:|| This algorithm computes the ratio of the spectral energy in the range| [startFrequency, stopFrequency] over the total energy.|| An exception is thrown when startFrequency is larger than stopFrequency| or the input spectrum is empty.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Entropy = class Algo(Algorithm)| Entropy||| Inputs:|| [vector_real] array - the input array (cannot contain negative values, and must be non-empty)||| Outputs:|| [real] entropy - the entropy of the input array||| Description:|| This algorithm computes the Shannon entropy of an array. Entropy can be used| to quantify the peakiness of a distribution. This has been used for| voiced/unvoiced decision in automatic speech recognition.|| Entropy cannot be computed neither on empty arrays nor arrays which contain| negative values. In such cases, exceptions will be thrown.|| References:| [1] H. Misra, S. Ikbal, H. Bourlard and H. Hermansky, "Spectral entropy| based feature for robust ASR," in IEEE International Conference on| Acoustics, Speech, and Signal Processing (ICASSP'04).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': "This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Envelope = class Algo(Algorithm)| Envelope||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the resulting envelope of the signal||| Parameters:|| applyRectification:| bool ∈ {true,false} (default = true)| whether to apply rectification (envelope based on the absolute value of| signal)|| attackTime:| real ∈ [0,inf) (default = 10)| the attack time of the first order lowpass in the attack phase [ms]|| releaseTime:| real ∈ [0,inf) (default = 1500)| the release time of the first order lowpass in the release phase [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the envelope of a signal by applying a non-symmetric| lowpass filter on a signal. By default it rectifies the signal, but that is| optional.|| References:| [1] U. Zölzer, Digital Audio Signal Processing,| John Wiley & Sons Ltd, 1997, ch.7|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EqloudLoader = class Algo(Algorithm)| EqloudLoader||| Outputs:|| [vector_real] audio - the audio signal||| Parameters:|| downmix:| string ∈ {left,right,mix} (default = "mix")| the mixing type for stereo files|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice to be extracted [s]|| filename:| string| the name of the file from which to read|| replayGain:| real ∈ (-inf,inf) (default = -6)| the value of the replayGain [dB] that should be used to normalize the| signal [dB]|| sampleRate:| real ∈ {32000,44100,48000} (default = 44100)| the output sampling rate [Hz]|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice to be extracted [s]||| Description:|| This algorithm loads the raw audio data from an audio file, downmixes it to| mono and normalizes using replayGain and equal-loudness filter. Audio is| resampled in case the given sampling rate does not match the sampling rate of| the input signal and normalized by the given replayGain gain. In addition,| audio data is filtered through an equal-loudness filter.|| This algorithm uses MonoLoader and thus inherits all of its input| requirements and exceptions.|| References:| [1] Replay Gain - A Proposed Standard,| http://replaygain.hydrogenaudio.org| [2] Replay Gain - Equal Loudness Filter,| http://replaygain.hydrogenaudio.org/proposal/equal_loudness.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).EqualLoudness = class Algo(Algorithm)| EqualLoudness||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| sampleRate:| real ∈ {8000,32000,44100,48000} (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements an equal-loudness filter. The human ear does not| perceive sounds of all frequencies as having equal loudness, and to account| for this, the signal is filtered by an inverted approximation of the| equal-loudness curves. Technically, the filter is a cascade of a 10th order| Yulewalk filter with a 2nd order Butterworth high pass filter.|| This algorithm depends on the IIR algorithm. Any requirements of the IIR| algorithm are imposed for this algorithm. This algorithm is only defined for| the sampling rates specified in parameters. It will throw an exception if| attempting to configure with any other sampling rate.|| References:| [1] Replay Gain - Equal Loudness Filter,| http://replaygain.hydrogenaudio.org/proposal/equal_loudness.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Extractor = class Algo(Algorithm)| Extractor||| Inputs:|| [vector_real] audio - the input audio signal||| Outputs:|| [pool] pool - the pool where to store the results||| Parameters:|| dynamics:| bool ∈ {true,false} (default = true)| compute dynamics' features|| dynamicsFrameSize:| integer ∈ (0,inf) (default = 88200)| the frame size for level dynamics|| dynamicsHopSize:| integer ∈ (0,inf) (default = 44100)| the hop size for level dynamics|| highLevel:| bool ∈ {true,false} (default = true)| compute high level features|| lowLevel:| bool ∈ {true,false} (default = true)| compute low level features|| lowLevelFrameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low level features|| lowLevelHopSize:| integer ∈ (0,inf) (default = 1024)| the hop size for computing low level features|| midLevel:| bool ∈ {true,false} (default = true)| compute mid level features|| namespace:| string (default = "")| the main namespace under which to store the results|| relativeIoi:| bool ∈ {true,false} (default = false)| compute relative inter onset intervals|| rhythm:| bool ∈ {true,false} (default = true)| compute rhythm features|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate|| tonalFrameSize:| integer ∈ (0,inf) (default = 4096)| the frame size for low level tonal features|| tonalHopSize:| integer ∈ (0,inf) (default = 2048)| the hop size for low level tonal features|| tuning:| bool ∈ {true,false} (default = true)| compute tuning frequency||| Description:|| This algorithm extracts all low-level, mid-level and high-level features from| an audio signal and stores them in a pool.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FFT = class Algo(Algorithm)| FFT||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_complex] fft - the FFT of the input frame||| Parameters:|| size:| integer ∈ [1,inf) (default = 1024)| the expected size of the input frame. This is purely optional and only| targeted at optimizing the creation time of the FFT object||| Description:|| This algorithm computes the positive complex short-term Fourier transform| (STFT) of an array using the FFT algorithm. The resulting fft has a size of| (s/2)+1, where s is the size of the input frame.| At the moment FFT can only be computed on frames which size is even and non| zero, otherwise an exception is thrown.|| References:| [1] Fast Fourier transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Fft|| [2] Fast Fourier Transform -- from Wolfram MathWorld,| http://mathworld.wolfram.com/FastFourierTransform.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FFTC = class Algo(Algorithm)| FFTC||| Inputs:|| [vector_complex] frame - the input frame (complex)||| Outputs:|| [vector_complex] fft - the FFT of the input frame||| Parameters:|| negativeFrequencies:| bool ∈ {true,false} (default = false)| returns the full spectrum or just the positive frequencies|| size:| integer ∈ [1,inf) (default = 1024)| the expected size of the input frame. This is purely optional and only| targeted at optimizing the creation time of the FFT object||| Description:|| This algorithm computes the complex short-term Fourier transform (STFT) of a| complex array using the FFT algorithm. If the `negativeFrequencies` flag is| set on, the resulting fft has a size of (s/2)+1, where s is the size of the| input frame. Otherwise, output matches the input size.| At the moment FFT can only be computed on frames which size is even and non| zero, otherwise an exception is thrown.|| References:| [1] Fast Fourier transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Fft|| [2] Fast Fourier Transform -- from Wolfram MathWorld,| http://mathworld.wolfram.com/FastFourierTransform.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FadeDetection = class Algo(Algorithm)| FadeDetection||| Inputs:|| [vector_real] rms - rms values array||| Outputs:|| [matrix_real] fadeIn - 2D-array containing start/stop timestamps corresponding to fade-ins [s] (ordered chronologically)| [matrix_real] fadeOut - 2D-array containing start/stop timestamps corresponding to fade-outs [s] (ordered chronologically)||| Parameters:|| cutoffHigh:| real ∈ (0,1] (default = 0.850000023842)| fraction of the average RMS to define the maximum threshold|| cutoffLow:| real ∈ [0,1) (default = 0.20000000298)| fraction of the average RMS to define the minimum threshold|| frameRate:| real ∈ (0,inf) (default = 4)| the rate of frames used in calculation of the RMS [frames/s]|| minLength:| real ∈ (0,inf) (default = 3)| the minimum length to consider a fade-in/out [s]||| Description:|| This algorithm detects fade-in and fade-outs time positions in an audio| signal given a sequence of RMS values. It outputs two arrays containing the| start/stop points of fade-ins and fade-outs. The main hypothesis for the| detection is that an increase or decrease of the RMS over time in an audio| file corresponds to a fade-in or fade-out, repectively. Minimum and maximum| mean-RMS-thresholds are used to define where fade-in and fade-outs occur.|| An exception is thrown if the input "rms" is empty.|| References:| [1] Fade (audio engineering) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Fade-in|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Duration/silence', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FalseStereoDetector = class Algo(Algorithm)| FalseStereoDetector||| Inputs:|| [vector_stereosample] frame - the input frame (must be non-empty)||| Outputs:|| [integer] isFalseStereo - a flag indicating if the frame channes are simmilar| [real] correlation - correlation betweeen the input channels||| Parameters:|| correlationThreshold:| real ∈ [-1,1] (default = 0.999499976635)| threshold to activate the isFalseStereo flag|| silenceThreshold:| integer ∈ (-inf,0) (default = -70)| Silent frames will be skkiped.||| Description:|| This algorithm detects if a stereo track has duplicated channels (false| stereo).It is based on the Pearson linear correlation coefficient and thus it| is robust scaling and shifting between channels.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Flatness = class Algo(Algorithm)| Flatness||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] flatness - the flatness (ratio between the geometric and the arithmetic mean of the input array)||| Description:|| This algorithm computes the flatness of an array, which is defined as the| ratio between the geometric mean and the arithmetic mean.|| Flatness is undefined for empty input and negative values, therefore an| exception is thrown in any both cases.|| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FlatnessDB = class Algo(Algorithm)| FlatnessDB||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] flatnessDB - the flatness dB||| Description:|| This algorithm computes the flatness of an array, which is defined as the| ratio between the geometric mean and the arithmetic mean converted to dB| scale.|| Specifically, it can be used to compute spectral flatness [1,2], which is a| measure of how noise-like a sound is, as opposed to being tone-like. The| meaning of tonal in this context is in the sense of the amount of peaks or| resonant structure in a power spectrum, as opposed to flat spectrum of a| white noise. A high spectral flatness (approaching 1.0 for white noise)| indicates that the spectrum has a similar amount of power in all spectral| bands — this would sound similar to white noise, and the graph of the| spectrum would appear relatively flat and smooth. A low spectral flatness| (approaching 0.0 for a pure tone) indicates that the spectral power is| concentrated in a relatively small number of bands — this would typically| sound like a mixture of sine waves, and the spectrum would appear "spiky"|| The size of the input array must be greater than 0. If the input array is| empty an exception will be thrown. This algorithm uses the Flatness algorithm| and thus inherits its input requirements and exceptions.|| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| [2] Spectral flatness - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Spectral_flatness|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FlatnessSFX = class Algo(Algorithm)| FlatnessSFX||| Inputs:|| [vector_real] envelope - the envelope of the signal||| Outputs:|| [real] flatness - the flatness coefficient||| Description:|| This algorithm calculates the flatness coefficient of a signal envelope.|| There are two thresholds defined: a lower one at 20% and an upper one at 95%.| The thresholds yield two values: one value which has 20% of the total values| underneath, and one value which has 95% of the total values underneath. The| flatness coefficient is then calculated as the ratio of these two values.| This algorithm is meant to be plugged after Envelope algorithm, however in| streaming mode a RealAccumulator algorithm should be connected in between the| two.| In the current form the algorithm can't be calculated in streaming mode,| since it would violate the streaming mode policy of having low memory| consumption.|| An exception is thrown if the input envelope is empty.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Flux = class Algo(Algorithm)| Flux||| Inputs:|| [vector_real] spectrum - the input spectrum||| Outputs:|| [real] flux - the spectral flux of the input spectrum||| Parameters:|| halfRectify:| bool ∈ {true,false} (default = false)| half-rectify the differences in each spectrum bin|| norm:| string ∈ {L1,L2} (default = "L2")| the norm to use for difference computation||| Description:|| This algorithm computes the spectral flux of a spectrum. Flux is defined as| the L2-norm [1] or L1-norm [2] of the difference between two consecutive| frames of the magnitude spectrum. The frames have to be of the same size in| order to yield a meaningful result. The default L2-norm is used more| commonly.|| An exception is thrown if the size of the input spectrum does not equal the| previous input spectrum's size.|| References:| [1] Tzanetakis, G., Cook, P., "Multifeature Audio Segmentation for| Browsing and Annotation", Proceedings of the 1999 IEEE Workshop on| Applications of Signal Processing to Audio and Acoustics, New Paltz,| NY, USA, 1999, W99 1-4|| [2] S. Dixon, "Onset detection revisited", in International Conference on| Digital Audio Effects (DAFx'06), 2006, vol. 120, pp. 133-137.|| [3] http://en.wikipedia.org/wiki/Spectral_flux|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FrameCutter = class Algo(Algorithm)| FrameCutter||| Inputs:|| [vector_real] signal - the buffer from which to read data||| Outputs:|| [vector_real] frame - the frame to write to||| Parameters:|| frameSize:| integer ∈ [1,inf) (default = 1024)| the output frame size|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| lastFrameToEndOfFile:| bool ∈ {true,false} (default = false)| whether the beginning of the last frame should reach the end of file. Only| applicable if startFromZero is true|| startFromZero:| bool ∈ {true,false} (default = false)| whether to start the first frame at time 0 (centered at frameSize/2) if| true, or -frameSize/2 otherwise (zero-centered)|| validFrameThresholdRatio:| real ∈ [0,1] (default = 0)| frames smaller than this ratio will be discarded, those larger will be| zero-padded to a full frame (i.e. a value of 0 will never discard frames| and a value of 1 will only keep frames that are of length 'frameSize')||| Description:|| This algorithm slices the input buffer into frames. It returns a frame of a| constant size and jumps a constant amount of samples forward in the buffer on| every compute() call until no more frames can be extracted; empty frame| vectors are returned afterwards. Incomplete frames (frames starting before| the beginning of the input buffer or going past its end) are zero-padded or| dropped according to the "validFrameThresholdRatio" parameter.|| The algorithm outputs as many frames as needed to consume all the information| contained in the input buffer. Depending on the "startFromZero" parameter:| - startFromZero = true: a frame is the last one if its end position is at| or beyond the end of the stream. The last frame will be zero-padded if its| size is less than "frameSize"| - startFromZero = false: a frame is the last one if its center position is| at or beyond the end of the stream| In both cases the start time of the last frame is never beyond the end of the| stream.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm s...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FrameToReal = class Algo(Algorithm)| FrameToReal||| Inputs:|| [vector_real] signal - the input audio frame||| Outputs:|| [vector_real] signal - the output audio samples||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing the overlap-add process|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the overlap-add function is computed||| Description:|| This algorithm converts a sequence of input audio signal frames into a| sequence of audio samples.|| Empty input signals will raise an exception.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FreesoundExtractor = class Algo(Algorithm)| FreesoundExtractor||| Inputs:|| [string] filename - the input audiofile||| Outputs:|| [pool] results - Analysis results pool with across-frames statistics| [pool] resultsFrames - Analysis results pool with computed frame values||| Parameters:|| analysisSampleRate:| real ∈ (0,inf) (default = 44100)| the analysis sampling rate of the audio signal [Hz]|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice you want to extract [s]|| gfccStats:| vector_string (default = ["mean", "cov", "icov"])| the statistics to compute for GFCC features|| highlevel:| vector_string| list of high-level classifier models (gaia2 history filenames) to apply| using extracted features. Skip classification if not specified (empty list)|| lowlevelFrameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low-level features|| lowlevelHopSize:| integer ∈ (0,inf) (default = 1024)| the hop size for computing low-level features|| lowlevelSilentFrames:| string ∈ {drop,keep,noise} (default = "noise")| whether to [keep/drop/add noise to] silent frames for computing low-level| features|| lowlevelStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for low-level features|| lowlevelWindowType:| string ∈ {hamming,hann,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "blackmanharris62")| the window type for computing low-level features|| lowlevelZeroPadding:| integer ∈ [0,inf) (default = 0)| zero padding factor for computing low-level features|| mfccStats:| vector_string (default = ["mean", "cov", "icov"])| the statistics to compute for MFCC features|| profile:| string| profile filename. If specified, default parameter values are overwritten by| values in the profile yaml file. If not specified (empty string), use| values configured by user like in other normal algorithms|| rhythmMaxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| rhythmMethod:| string ∈ {multifeature,degara} (default = "degara")| the method used for beat tracking|| rhythmMinTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]|| rhythmStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for rhythm features|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice you want to extract [s]|| tonalFrameSize:| integer ∈ (0,inf) (default = 4096)| the frame size for computing tonal features|| tonalHopSize:| integer ∈ (0,inf) (default = 2048)| the hop size for computing tonal features|| tonalSilentFrames:| string ∈ {drop,keep,noise} (default = "noise")| whether to [keep/drop/add noise to] silent frames for computing tonal| features|| tonalStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for tonal features|| tonalWindowType:| string ∈ {hamming,hann,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "blackmanharris62")| the window type for computing tonal features|| tonalZeroPadding:| integer ∈ [0,inf) (default = 0)| zero padding factor for computing tonal features||| Description:|| This algorithm is a wrapper for Freesound Extractor. See documentation for| 'essentia_streaming_extractor_freesound'.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': "This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).FrequencyBands = class Algo(Algorithm)| FrequencyBands||| Inputs:|| [vector_real] spectrum - the input spectrum (must be greater than size one)||| Outputs:|| [vector_real] bands - the energy in each band||| Parameters:|| frequencyBands:| vector_real (default = [0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2000, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12000, 15500, 20500, 27000])| list of frequency ranges in to which the spectrum is divided (these must be| in ascending order and connot contain duplicates)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes energy in rectangular frequency bands of a spectrum.| The bands are non-overlapping. For each band the power-spectrum (mag-squared)| is summed.|| Parameter "frequencyBands" must contain at least 2 frequencies, they all must| be positive and must be ordered ascentdantly, otherwise an exception will be| thrown. FrequencyBands is only defined for spectra, which size is greater| than 1.|| References:| [1] Frequency Range - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Frequency_band|| [2] Band - Handbook For Acoustic Ecology,| http://www.sfu.ca/sonic-studio/handbook/Band.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).GFCC = class Algo(Algorithm)| GFCC||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energies in ERB bands| [vector_real] gfcc - the gammatone feature cepstrum coefficients||| Parameters:|| dctType:| integer ∈ [2,3] (default = 2)| the DCT type|| highFrequencyBound:| real ∈ (0,inf) (default = 22050)| the upper bound of the frequency range [Hz]|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of input spectrum|| logType:| string ∈ {natural,dbpow,dbamp,log} (default = "dbamp")| logarithmic compression type. Use 'dbpow' if working with power and 'dbamp'| if working with magnitudes|| lowFrequencyBound:| real ∈ [0,inf) (default = 40)| the lower bound of the frequency range [Hz]|| numberBands:| integer ∈ [1,inf) (default = 40)| the number of bands in the filter|| numberCoefficients:| integer ∈ [1,inf) (default = 13)| the number of output cepstrum coefficients|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| silenceThreshold:| real ∈ (0,inf) (default = 1.00000001335e-10)| silence threshold for computing log-energy bands|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum||| Description:|| This algorithm computes the Gammatone-frequency cepstral coefficients of a| spectrum. This is an equivalent of MFCCs, but using a gammatone filterbank| (ERBBands) scaled on an Equivalent Rectangular Bandwidth (ERB) scale.|| References:| [1] Y. Shao, Z. Jin, D. Wang, and S. Srinivasan, "An auditory-based feature| for robust speech recognition," in IEEE International Conference on| Acoustics, Speech, and Signal Processing (ICASSP’09), 2009,| pp. 4625-4628.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).GaiaTransform = class Algo(Algorithm)| GaiaTransform||| Inputs:|| [pool] pool - aggregated pool of extracted values||| Outputs:|| [pool] pool - pool resulting from the transformation of the gaia point||| Parameters:|| history:| string| gaia2 history filename||| Description:|| Applies a given Gaia2 transformation history to a given pool. It first| converts the pool into a gaia2::Point suitable for the history, applies the| history, and converts back the resulting point into an essentia Pool. In| particular, it allows classification.|| Note that in order to enable this algorithm it is necessary to install Gaia2| library before building Essentia.|| References:| [1] Gaia - A library for similarity in high-dimensional spaces,| http://github.com/MTG/gaia|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Transformations', 'description': 'Applies a...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).GapsDetector = class Algo(Algorithm)| GapsDetector||| Inputs:|| [vector_real] frame - the input frame (must be non-empty)||| Outputs:|| [vector_real] starts - the start indexes of the detected gaps (if any) in seconds| [vector_real] ends - the end indexes of the detected gaps (if any) in seconds||| Parameters:|| attackTime:| real ∈ [0,inf) (default = 0.0500000007451)| the attack time of the first order lowpass in the attack phase [ms]|| frameSize:| integer ∈ [0,inf) (default = 2048)| frame size used for the analysis. Should match the input frame size.| Otherwise, an exception will be thrown|| hopSize:| integer ∈ [0,inf) (default = 1024)| hop size used for the analysis|| kernelSize:| integer ∈ [1,inf) (default = 11)| scalar giving the size of the median filter window. Must be odd|| maximumTime:| real ∈ (0,inf) (default = 3500)| time of the maximum gap duration [ms]|| minimumTime:| real ∈ (0,inf) (default = 10)| time of the minimum gap duration [ms]|| postpowerTime:| real ∈ (0,inf) (default = 40)| time for the postpower calculation [ms]|| prepowerThreshold:| real ∈ (-inf,inf) (default = -30)| prepower threshold [dB].|| prepowerTime:| real ∈ (0,inf) (default = 40)| time for the prepower calculation [ms]|| releaseTime:| real ∈ [0,inf) (default = 0.0500000007451)| the release time of the first order lowpass in the release phase [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| sample rate used for the analysis|| silenceThreshold:| real ∈ (-inf,inf) (default = -50)| silence threshold [dB]||| Description:|| This algorithm uses energy and time thresholds to detect gaps in the| waveform. A median filter is used to remove spurious silent samples. The| power of a small audio region before the detected gaps (prepower) is| thresholded to detect intentional pauses as described in [1]. This technique| isextended to the region after the gap.| The algorithm was designed for a framewise use and returns the start and end| timestamps related to the first frame processed. Call configure() or reset()| in order to restart the count.|| References:| [1] Mühlbauer, R. (2010). Automatic Audio Defect Detection.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).GeometricMean = class Algo(Algorithm)| GeometricMean||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] geometricMean - the geometric mean of the input array||| Description:|| This algorithm computes the geometric mean of an array of positive values.|| An exception is thrown if the input array does not contain strictly positive| numbers or the array is empty.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| [2] Geometric Mean -- from Wolfram MathWorld,| http://mathworld.wolfram.com/GeometricMean.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HFC = class Algo(Algorithm)| HFC||| Inputs:|| [vector_real] spectrum - the input audio spectrum||| Outputs:|| [real] hfc - the high-frequency coefficient||| Parameters:|| sampleRate:| real ∈ (0,inf] (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {Masri,Jensen,Brossier} (default = "Masri")| the type of HFC coefficient to be computed||| Description:|| This algorithm computes the High Frequency Content of a spectrum. It can be| computed according to the following techniques:| - 'Masri' (default) which does: sum |X(n)|^2*k,| - 'Jensen' which does: sum |X(n)|*k^2| - 'Brossier' which does: sum |X(n)|*k|| Exception is thrown for empty input spectra.|| References:| [1] P. Masri and A. Bateman, “Improved modelling of attack transients in| music analysis-resynthesis,” in Proceedings of the International| Computer Music Conference, 1996, pp. 100–103.|| [2] K. Jensen and T. H. Andersen, “Beat estimation on the beat,” in| Applications of Signal Processing to Audio and Acoustics, 2003 IEEE| Workshop on., 2003, pp. 87–90.|| [3] High frequency content measure - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/High_Frequency_Content_measure|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HPCP = class Algo(Algorithm)| HPCP||| Inputs:|| [vector_real] frequencies - the frequencies of the spectral peaks [Hz]| [vector_real] magnitudes - the magnitudes of the spectral peaks||| Outputs:|| [vector_real] hpcp - the resulting harmonic pitch class profile||| Parameters:|| bandPreset:| bool ∈ {true,false} (default = true)| enables whether to use a band preset|| bandSplitFrequency:| real ∈ (0,inf) (default = 500)| the split frequency for low and high bands, not used if bandPreset is false| [Hz]|| harmonics:| integer ∈ [0,inf) (default = 0)| number of harmonics for frequency contribution, 0 indicates exclusive| fundamental frequency contribution|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency that contributes to the HPCP [Hz] (the difference| between the max and split frequencies must not be less than 200.0 Hz)|| maxShifted:| bool ∈ {true,false} (default = false)| whether to shift the HPCP vector so that the maximum peak is at index 0|| minFrequency:| real ∈ (0,inf) (default = 40)| the minimum frequency that contributes to the HPCP [Hz] (the difference| between the min and split frequencies must not be less than 200.0 Hz)|| nonLinear:| bool ∈ {true,false} (default = false)| apply non-linear post-processing to the output (use with| normalized='unitMax'). Boosts values close to 1, decreases values close to| 0.|| normalized:| string ∈ {none,unitSum,unitMax} (default = "unitMax")| whether to normalize the HPCP vector|| referenceFrequency:| real ∈ (0,inf) (default = 440)| the reference frequency for semitone index calculation, corresponding to A3| [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| size:| integer ∈ [12,inf) (default = 12)| the size of the output HPCP (must be a positive nonzero multiple of 12)|| weightType:| string ∈ {none,cosine,squaredCosine} (default = "squaredCosine")| type of weighting function for determining frequency contribution|| windowSize:| real ∈ (0,12] (default = 1)| the size, in semitones, of the window used for the weighting||| Description:|| Computes a Harmonic Pitch Class Profile (HPCP) from the spectral peaks of a| signal. HPCP is a k*12 dimensional vector which represents the intensities of| the twelve (k==1) semitone pitch classes (corresponsing to notes from A to| G#), or subdivisions of these (k>1).|| Exceptions are thrown if "minFrequency", "bandSplitFrequency" and| "maxFrequency" are not separated by at least 200Hz from each other, requiring| that "maxFrequency" be greater than "bandSplitFrequency" and| "bandSplitFrequency" be greater than "minFrequency". Other exceptions are| thrown if input vectors have different size, if parameter "size" is not a| positive non-zero multiple of 12 or if "windowSize" is less than one hpcp bin| (12/size).|| References:| [1] T. Fujishima, "Realtime Chord Recognition of Musical Sound: A System| Using Common Lisp Music," in International Computer Music Conference| (ICMC'99), pp. 464-467, 1999.|| [2] E. Gómez, "Tonal Description of Polyphonic Audio for Music Content| Processing," INFORMS Journal on Computing, vol. 18, no. 3, pp. 294–304,| 2006.|| [3] Harmonic pitch class profiles - Wikipedia, the free encyclopedia,| https://en.wikipedia.org/wiki/Harmonic_pitch_class_profiles|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'Computes a Harmonic...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HarmonicBpm = class Algo(Algorithm)| HarmonicBpm||| Inputs:|| [vector_real] bpms - list of bpm candidates||| Outputs:|| [vector_real] harmonicBpms - a list of bpms which are harmonically related to the bpm parameter||| Parameters:|| bpm:| integer ∈ [1,inf) (default = 60)| the bpm used to find its harmonics|| threshold:| real ∈ [1,inf) (default = 20)| bpm threshold below which greatest common divisors are discarded|| tolerance:| real ∈ [0,inf) (default = 5)| percentage tolerance to consider two bpms are equal or equal to a harmonic||| Description:|| This algorithm extracts bpms that are harmonically related to the tempo given| by the 'bpm' parameter.| The algorithm assumes a certain bpm is harmonically related to parameter bpm,| when the greatest common divisor between both bpms is greater than threshold.| The 'tolerance' parameter is needed in order to consider if two bpms are| related. For instance, 120, 122 and 236 may be related or not depending on| how much tolerance is given|| References:| [1] Greatest common divisor - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Greatest_common_divisor|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm ext...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HarmonicMask = class Algo(Algorithm)| HarmonicMask||| Inputs:|| [vector_complex] fft - the input frame| [real] pitch - an estimate of the fundamental frequency of the signal [Hz]||| Outputs:|| [vector_complex] fft - the output frame||| Parameters:|| attenuation:| real ∈ [-inf,inf) (default = -200)| attenuation in dB's of the muted pitched component. If value is positive| the pitched component is attenuated (muted), if the value is negative the| pitched component is soloed (i.e. background component is attenuated).|| binWidth:| integer ∈ [0,inf) (default = 4)| number of bins per harmonic partials applied to the mask. This will depend| on the internal FFT size|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm applies a spectral mask to remove a pitched source component| from the signal. It computes first an harmonic mask corresponding to the| input pitch and applies the mask to the input FFT to remove that pitch. The| bin width determines how many spectral bins are masked per harmonic partial.| An attenuation value in dB determines the amount of suppression of the| pitched component w.r.t the background for the case of muting. A negative| attenuation value allows soloing the pitched component.|| References:|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HarmonicModelAnal = class Algo(Algorithm)| HarmonicModelAnal||| Inputs:|| [vector_complex] fft - the input fft| [real] pitch - external pitch input [Hz].||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks||| Parameters:|| freqDevOffset:| real ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| harmDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| magnitudeThreshold:| real ∈ (-inf,inf) (default = -74)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the F0 [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ (0,inf) (default = 20)| the minimum frequency of the F0 [Hz]|| nHarmonics:| integer ∈ (0,inf) (default = 100)| maximum number of harmonics per frame|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the harmonic model analysis.|| This algorithm uses SineModelAnal and keeps only the harmonic partials. It| receives an external pitch value as input. You can use PitchYinFft algorithm| to compute the pitch per frame.|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HarmonicPeaks = class Algo(Algorithm)| HarmonicPeaks||| Inputs:|| [vector_real] frequencies - the frequencies of the spectral peaks [Hz] (ascending order)| [vector_real] magnitudes - the magnitudes of the spectral peaks (ascending frequency order)| [real] pitch - an estimate of the fundamental frequency of the signal [Hz]||| Outputs:|| [vector_real] harmonicFrequencies - the frequencies of harmonic peaks [Hz]| [vector_real] harmonicMagnitudes - the magnitudes of harmonic peaks||| Parameters:|| maxHarmonics:| integer ∈ [1,inf) (default = 20)| the number of harmonics to return including F0|| tolerance:| real ∈ (0,0.5) (default = 0.20000000298)| the allowed ratio deviation from ideal harmonics||| Description:|| This algorithm finds the harmonic peaks of a signal given its spectral peaks| and its fundamental frequency.| Note:| - "tolerance" parameter defines the allowed fixed deviation from ideal| harmonics, being a percentage over the F0. For example: if the F0 is 100Hz| you may decide to allow a deviation of 20%, that is a fixed deviation of| 20Hz; for the harmonic series it is: [180-220], [280-320], [380-420], etc.| - If "pitch" is zero, it means its value is unknown, or the sound is| unpitched, and in that case the HarmonicPeaks algorithm returns an empty| vector.| - The output frequency and magnitude vectors are of size "maxHarmonics". If| a particular harmonic was not found among spectral peaks, its ideal frequency| value is output together with 0 magnitude.| This algorithm is intended to receive its "frequencies" and "magnitudes"| inputs from the SpectralPeaks algorithm.| - When input vectors differ in size or are empty, an exception is thrown.| Input vectors must be ordered by ascending frequency excluding DC components| and not contain duplicates, otherwise an exception is thrown.|| References:| [1] Harmonic Spectrum - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Harmonic_spectrum|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm find...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HighPass = class Algo(Algorithm)| HighPass||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| cutoffFrequency:| real ∈ (0,inf) (default = 1500)| the cutoff frequency for the filter [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements a 1st order IIR high-pass filter. Because of its| dependence on IIR, IIR's requirements are inherited.|| References:| [1] U. Zölzer, DAFX - Digital Audio Effects, p. 40,| John Wiley & Sons, 2002|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HighResolutionFeatures = class Algo(Algorithm)| HighResolutionFeatures||| Inputs:|| [vector_real] hpcp - the HPCPs, preferably of size >= 120||| Outputs:|| [real] equalTemperedDeviation - measure of the deviation of HPCP local maxima with respect to equal-tempered bins| [real] nonTemperedEnergyRatio - ratio between the energy on non-tempered bins and the total energy| [real] nonTemperedPeaksEnergyRatio - ratio between the energy on non-tempered peaks and the total energy||| Parameters:|| maxPeaks:| integer ∈ [1,inf) (default = 24)| maximum number of HPCP peaks to consider when calculating outputs||| Description:|| This algorithm computes high-resolution chroma features from an HPCP vector.| The vector's size must be a multiple of 12 and it is recommended that it be| larger than 120. In otherwords, the HPCP's resolution should be 10 Cents or| more.| The high-resolution features being computed are:|| - Equal-temperament deviation: a measure of the deviation of HPCP local| maxima with respect to equal-tempered bins. This is done by:| a) Computing local maxima of HPCP vector| b) Computing the deviations from equal-tempered (abs) bins and their| average|| - Non-tempered energy ratio: the ratio betwen the energy on non-tempered| bins and the total energy, computed from the HPCP average|| - Non-tempered peak energy ratio: the ratio betwen the energy on non| tempered peaks and the total energy, computed from the HPCP average|| HighFrequencyFeatures is intended to be used in conjunction with HPCP| algorithm. Any input vector which size is not a positive multiple of 12, will| raise an exception.|| References:| [1] E. Gómez and P. Herrera, "Comparative Analysis of Music Recordings| from Western and Non-Western traditions by Automatic Tonal Feature| Extraction," Empirical Musicology Review, vol. 3, pp. 140–156, 2008.|| [2] https://en.wikipedia.org/wiki/Equal_temperament|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Histogram = class Algo(Algorithm)| Histogram||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] histogram - the values in the equally-spaced bins| [vector_real] binEdges - the edges of the equally-spaced bins. Size is _histogram.size() + 1||| Parameters:|| maxValue:| real ∈ [0, Inf) (default = 1)| the max value of the histogram|| minValue:| real ∈ [0, Inf) (default = 0)| the min value of the histogram|| normalize:| string ∈ {none,unit_sum,unit_max} (default = "none")| the normalization setting.|| numberBins:| integer ∈ (0, Inf) (default = 10)| the number of bins||| Description:|| This algorithm computes a histogram. Values outside the range are ignored|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HprModelAnal = class Algo(Algorithm)| HprModelAnal||| Inputs:|| [vector_real] frame - the input frame| [real] pitch - external pitch input [Hz].||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] res - output residual frame||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| freqDevOffset:| integer ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| harmDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| magnitudeThreshold:| real ∈ (-inf,inf) (default = 0)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ (0,inf) (default = 20)| the minimum frequency of the range to evaluate [Hz]|| nHarmonics:| integer ∈ (0,inf) (default = 100)| maximum number of harmonics per frame|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the harmonic plus residual model analysis.|| It uses the algorithms HarmonicModelAnal and SineSubtraction .|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HpsModelAnal = class Algo(Algorithm)| HpsModelAnal||| Inputs:|| [vector_real] frame - the input frame| [real] pitch - external pitch input [Hz].||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] stocenv - the stochastic envelope||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| freqDevOffset:| integer ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| harmDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| magnitudeThreshold:| real ∈ (-inf,inf) (default = 0)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ (0,inf) (default = 20)| the minimum frequency of the range to evaluate [Hz]|| nHarmonics:| integer ∈ (0,inf) (default = 100)| maximum number of harmonics per frame|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the harmonic plus stochastic model analysis.|| It uses the algorithms HarmonicModelAnal and StochasticModelAnal .|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).HumDetector = class Algo(Algorithm)| HumDetector||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [matrix_real] r - the quantile ratios matrix| [vector_real] frequencies - humming tones frequencies| [vector_real] saliences - humming tones saliences| [vector_real] starts - humming tones starts| [vector_real] ends - humming tones ends||| Parameters:|| Q0:| real ∈ (0,1) (default = 0.10000000149)| low quantile|| Q1:| real ∈ (0,1) (default = 0.550000011921)| high quatile|| detectionThreshold:| real ∈ (0,inf) (default = 5)| the detection threshold for the peaks of the r matrix|| frameSize:| real ∈ (0,inf) (default = 0.40000000596)| the frame size with which the loudness is computed [s]|| hopSize:| real ∈ (0,inf) (default = 0.20000000298)| the hop size with which the loudness is computed [s]|| maximumFrequency:| real ∈ (0,inf) (default = 400)| maximum frequency to consider [Hz]|| minimumDuration:| real ∈ (0,inf) (default = 2)| minimun duration of the humming tones [s]|| minimumFrequency:| real ∈ (0,inf) (default = 22.5)| minimum frequency to consider [Hz]|| numberHarmonics:| integer ∈ (0,inf) (default = 1)| number of considered harmonics|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| timeContinuity:| real ∈ (0,inf) (default = 10)| time continuity cue (the maximum allowed gap duration for a pitch contour)| [s]|| timeWindow:| real ∈ (0,inf) (default = 10)| analysis time to use for the hum estimation [s]||| Description:|| This algorithm detects low frequency tonal noises in the audio signal. First,| the steadiness of the Power Spectral Density (PSD) of the signal is computed| by measuring the quantile ratios as described in [1]. After this, the| PitchContours algorithm is used to keep track of the humming tones [2].|| References:| [1] Brandt, M., & Bitzer, J. (2014). Automatic Detection of Hum in Audio| Signals. Journal of the Audio Engineering Society, 62(9), 584-595.| [2] J. Salamon and E. Gómez, Melody extraction from polyphonic music| signals| using pitch contour characteristics, IEEE Transactions on Audio, Speech,| and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).IDCT = class Algo(Algorithm)| IDCT||| Inputs:|| [vector_real] dct - the discrete cosine transform||| Outputs:|| [vector_real] idct - the inverse cosine transform of the input array||| Parameters:|| dctType:| integer ∈ [2,3] (default = 2)| the DCT type|| inputSize:| integer ∈ [1,inf) (default = 10)| the size of the input array|| liftering:| integer ∈ [0,inf) (default = 0)| the liftering coefficient. Use '0' to bypass it|| outputSize:| integer ∈ [1,inf) (default = 10)| the number of output coefficients||| Description:|| This algorithm computes the Inverse Discrete Cosine Transform of an array.| It can be configured to perform the inverse DCT-II form, with the 1/sqrt(2)| scaling factor for the first coefficient or the inverse DCT-III form based on| the HTK implementation.|| IDCT can be used to compute smoothed Mel Bands. In order to do this:| - compute MFCC| - smoothedMelBands = 10^(IDCT(MFCC)/20)| Note: The second step assumes that 'logType' = 'dbamp' was used to compute| MFCCs, otherwise that formula should be changed in order to be consistent.|| Note: The 'inputSize' parameter is only used as an optimization when the| algorithm is configured. The IDCT will automatically adjust to the size of| any input.|| References:| [1] Discrete cosine transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Discrete_cosine_transform| [2] HTK book, chapter 5.6 ,| http://speech.ee.ntu.edu.tw/homework/DSP_HW2-1/htkbook.pdf|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).IFFT = class Algo(Algorithm)| IFFT||| Inputs:|| [vector_complex] fft - the input frame||| Outputs:|| [vector_real] frame - the IFFT of the input frame||| Parameters:|| normalize:| bool ∈ {true,false} (default = true)| wheter to normalize the output by the FFT length.|| size:| integer ∈ [1,inf) (default = 1024)| the expected size of the input frame. This is purely optional and only| targeted at optimizing the creation time of the FFT object||| Description:|| This algorithm calculates the inverse short-term Fourier transform (STFT) of| an array of complex values using the FFT algorithm. The resulting frame has a| size of (s-1)*2, where s is the size of the input fft frame. The inverse| Fourier transform is not defined for frames which size is less than 2| samples. Otherwise an exception is thrown.|| An exception is thrown if the input's size is not larger than 1.|| References:| [1] Fast Fourier transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Fft|| [2] Fast Fourier Transform -- from Wolfram MathWorld,| http://mathworld.wolfram.com/FastFourierTransform.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).IFFTC = class Algo(Algorithm)| IFFTC||| Inputs:|| [vector_complex] fft - the input frame||| Outputs:|| [vector_complex] frame - the complex IFFT of the input frame||| Parameters:|| normalize:| bool ∈ {true,false} (default = true)| wheter to normalize the output by the FFT length.|| size:| integer ∈ [1,inf) (default = 1024)| the expected size of the input frame. This is purely optional and only| targeted at optimizing the creation time of the FFT object||| Description:|| This algorithm calculates the inverse short-term Fourier transform (STFT) of| an array of complex values using the FFT algorithm. The resulting frame has a| size equal to the input fft frame size. The inverse Fourier transform is not| defined for frames which size is less than 2 samples. Otherwise an exception| is thrown.|| An exception is thrown if the input's size is not larger than 1.|| References:| [1] Fast Fourier transform - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Fft|| [2] Fast Fourier Transform -- from Wolfram MathWorld,| http://mathworld.wolfram.com/FastFourierTransform.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).IIR = class Algo(Algorithm)| IIR||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| denominator:| vector_real (default = [1])| the list of coefficients of the denominator. Often referred to as the A| coefficient vector.|| numerator:| vector_real (default = [1])| the list of coefficients of the numerator. Often referred to as the B| coefficient vector.||| Description:|| This algorithm implements a standard IIR filter. It filters the data in the| input vector with the filter described by parameter vectors 'numerator' and| 'denominator' to create the output filtered vector. In the litterature, the| numerator is often referred to as the 'B' coefficients and the denominator as| the 'A' coefficients.|| The filter is a Direct Form II Transposed implementation of the standard| difference equation:| a(0)*y(n) = b(0)*x(n) + b(1)*x(n-1) + ... + b(nb-1)*x(n-nb+1) - a(1)*y(n-1)| - ... - a(nb-1)*y(n-na+1)|| This algorithm maintains a state which is the state of the delays. One should| call the reset() method to reinitialize the state to all zeros.|| An exception is thrown if the "numerator" or "denominator" parameters are| empty. An exception is also thrown if the first coefficient of the| "denominator" parameter is 0.|| References:| [1] Smith, J.O. Introduction to Digital Filters with Audio Applications,| http://ccrma-www.stanford.edu/~jos/filters/|| [2] Infinite Impulse Response - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/IIR|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Inharmonicity = class Algo(Algorithm)| Inharmonicity||| Inputs:|| [vector_real] frequencies - the frequencies of the harmonic peaks [Hz] (in ascending order)| [vector_real] magnitudes - the magnitudes of the harmonic peaks (in frequency ascending order||| Outputs:|| [real] inharmonicity - the inharmonicity of the audio signal||| Description:|| This algorithm calculates the inharmonicity of a signal given its spectral| peaks. The inharmonicity value is computed as an energy weighted divergence| of the spectral components from their closest multiple of the fundamental| frequency. The fundamental frequency is taken as the first spectral peak from| the input. The inharmonicity value ranges from 0 (purely harmonic signal) to| 1 (inharmonic signal).|| Inharmonicity was designed to be fed by the output from the HarmonicPeaks| algorithm. Note that DC components should be removed from the signal before| obtaining its peaks. An exception is thrown if a peak is given at 0Hz.|| An exception is thrown if frequency vector is not sorted in ascendently, if| it contains duplicates or if any input vector is empty.|| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004.|| [2] Inharmonicity - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Inharmonicity|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm calc...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).InstantPower = class Algo(Algorithm)| InstantPower||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] power - the instant power of the input array||| Description:|| This algorithm computes the instant power of an array. That is, the energy of| the array over its size.|| An exception is thrown when input array is empty.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Intensity = class Algo(Algorithm)| Intensity||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [integer] intensity - the intensity value||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the input audio sampling rate [Hz]||| Description:|| This algorithm classifies the input audio signal as either relaxed (-1),| moderate (0), or aggressive (1).|| Quality: outdated (non-reliable, poor accuracy).|| An exception is thrown if empty input is provided because the "intensity" is| not defined for that case.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Key = class Algo(Algorithm)| Key||| Inputs:|| [vector_real] pcp - the input pitch class profile||| Outputs:|| [string] key - the estimated key, from A to G| [string] scale - the scale of the key (major or minor)| [real] strength - the strength of the estimated key| [real] firstToSecondRelativeStrength - the relative strength difference between the best estimate and second best estimate of the key||| Parameters:|| numHarmonics:| integer ∈ [1,inf) (default = 4)| number of harmonics that should contribute to the polyphonic profile (1| only considers the fundamental harmonic)|| pcpSize:| integer ∈ [12,inf) (default = 36)| number of array elements used to represent a semitone times 12 (this| parameter is only a hint, during computation, the size of the input PCP is| used instead)|| profileType:| string ∈ {diatonic,krumhansl,temperley,weichai,tonictriad,temperley2005,thpcp,shaath,gomez,noland,edmm,edma,bgate,braw} (default = "bgate")| the type of polyphic profile to use for correlation calculation|| slope:| real ∈ [0,inf) (default = 0.600000023842)| value of the slope of the exponential harmonic contribution to the| polyphonic profile|| useMajMin:| bool ∈ {true,false} (default = false)| use a third profile called 'majmin' for ambiguous tracks [4]. Only avalable| for the edma, bgate and braw profiles|| usePolyphony:| bool ∈ {true,false} (default = true)| enables the use of polyphonic profiles to define key profiles (this| includes the contributions from triads as well as pitch harmonics)|| useThreeChords:| bool ∈ {true,false} (default = true)| consider only the 3 main triad chords of the key (T, D, SD) to build the| polyphonic profiles||| Description:|| This algorithm computes key estimate given a pitch class profile (HPCP). The| algorithm was severely adapted and changed from the original implementation| for readability and speed.|| Key will throw exceptions either when the input pcp size is not a positive| multiple of 12 or if the key could not be found. Also if parameter "scale" is| set to "minor" and the profile type is set to "weichai"|| Abouth the Key Profiles:| - 'Diatonic' - binary profile with diatonic notes of both modes. Could be| useful for ambient music or diatonic music which is not strictly 'tonal| functional'.| - 'Tonic Triad' - just the notes of the major and minor chords. Exclusively| for testing.| - 'Krumhansl' - reference key profiles after cognitive experiments with| users. They should work generally fine for pop music.| - 'Temperley' - key profiles extracted from corpus analysis of| euroclassical music. Therefore, they perform best on this repertoire| (especially in minor).| - 'Shaath' - profiles based on Krumhansl's specifically tuned to popular| and electronic music.| - 'Noland' - profiles from Bach's 'Well Tempered Klavier'.| - 'edma' - automatic profiles extracted from corpus analysis of electronic| dance music [3]. They normally perform better that Shaath's| - 'edmm' - automatic profiles extracted from corpus analysis of electronic| dance music and manually tweaked according to heuristic observation. It will| report major modes (which are poorly represented in EDM) as minor, but| improve performance otherwise [3].| - 'braw' - profiles obtained by calculating the median profile for each| mode from a subset of BeatPort dataset. There is an extra profile obtained| from ambiguous tracks that are reported as minor[4]| - 'bgate' - same as braw but zeroing the 4 less relevant elements of each| profile[4]|| The standard mode of the algorithm estimates key/scale for a given HPCP| vector.|| The streaming mode first accumulates a stream of HPCP vectors and computes| its mean to provide the estimation. In this mode, the algorithm can apply a| tuning correction, based on peaks in the bins of the accumulated HPCP| distribution [3] (the `averageDetuningCorrection` parameter). This detuning| approach requires a high resolution of the input HPCP vectors (`pcpSize`| larger than 12).|| References:| [1] E. Gómez, "Tonal Description of Polyphonic Audio for Music Content| Processing," INFORMS Journal on Computing, vol. 18, no. 3, pp. 294–304,| 2006.|| [2] D. Temperley, "What's key for key? The Krumhansl-Schmuckler| key-finding algorithm reconsidered", Music Perception vol. 17, no. 1,| pp. 65-100, 1999. [3] Á. Faraldo, E. Gómez, S. Jordà, P.Herrera, "Key| Estimation in Electronic| Dance Music. Proceedings of the 38th International Conference on| information| Retrieval, Padova, 2016. (In Press.)| [4] Faraldo, Á., Jordà, S., & Herrera, P. (2017, June). A multi-profile| method| for key estimation in edm. In Audio Engineering Society Conference: 2017| AES| International Conference on Semantic Audio. Audio Engineering Society.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).KeyExtractor = class Algo(Algorithm)| KeyExtractor||| Inputs:|| [vector_real] audio - the audio input signal||| Outputs:|| [string] key - See Key algorithm documentation| [string] scale - See Key algorithm documentation| [real] strength - See Key algorithm documentation||| Parameters:|| averageDetuningCorrection:| bool ∈ {true,false} (default = true)| shifts a pcp to the nearest tempered bin|| frameSize:| integer ∈ (0,inf) (default = 4096)| the framesize for computing tonal features|| hopSize:| integer ∈ (0,inf) (default = 4096)| the hopsize for computing tonal features|| hpcpSize:| integer ∈ [12,inf) (default = 12)| the size of the output HPCP (must be a positive nonzero multiple of 12)|| maxFrequency:| real ∈ (0,inf) (default = 3500)| max frequency to apply whitening to [Hz]|| maximumSpectralPeaks:| integer ∈ (0,inf) (default = 60)| the maximum number of spectral peaks|| minFrequency:| real ∈ (0,inf) (default = 25)| min frequency to apply whitening to [Hz]|| pcpThreshold:| real ∈ [0,1] (default = 0.20000000298)| pcp bins below this value are set to 0|| profileType:| string ∈ {diatonic,krumhansl,temperley,weichai,tonictriad,temperley2005,thpcp,shaath,gomez,noland,faraldo,pentatonic,edmm,edma,bgate,braw} (default = "bgate")| the type of polyphic profile to use for correlation calculation|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| spectralPeaksThreshold:| real ∈ (0,inf) (default = 9.99999974738e-05)| the threshold for the spectral peaks|| tuningFrequency:| real ∈ (0,inf) (default = 440)| the tuning frequency of the input signal|| weightType:| string ∈ {none,cosine,squaredCosine} (default = "cosine")| type of weighting function for determining frequency contribution|| windowType:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'||| Description:|| This algorithm extracts key/scale for an audio signal. It computes HPCP| frames for the input signal and applies key estimation using the Key| algorithm.|| The algorithm allows tuning correction using two complementary methods:| - Specify the expected `tuningFrequency` for the HPCP computation. The| algorithm will adapt the semitone crossover frequencies for computing the| HPCPs accordingly. If not specified, the default tuning is used. Tuning| frequency can be estimated in advance using TuningFrequency algorithm.| - Apply tuning correction posterior to HPCP computation, based on peaks in| the HPCP distribution (`averageDetuningCorrection`). This is possible when| hpcpSize > 12.|| For more information, see the HPCP and Key algorithms.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm extr...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LPC = class Algo(Algorithm)| LPC||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] lpc - the LPC coefficients| [vector_real] reflection - the reflection coefficients||| Parameters:|| order:| integer ∈ [2,inf) (default = 10)| the order of the LPC analysis (typically [8,14])|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {regular,warped} (default = "regular")| the type of LPC (regular or warped)||| Description:|| This algorithm computes Linear Predictive Coefficients and associated| reflection coefficients of a signal.|| An exception is thrown if the "order" provided is larger than the size of the| input signal.|| References:| [1] Linear predictive coding - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Linear_predictive_coding|| [2] J. Makhoul, "Spectral analysis of speech by linear prediction," IEEE| Transactions on Audio and Electroacoustics, vol. 21, no. 3, pp. 140–148,| 1973.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Larm = class Algo(Algorithm)| Larm||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [real] larm - the LARM loudness estimate [dB]||| Parameters:|| attackTime:| real ∈ [0,inf) (default = 10)| the attack time of the first order lowpass in the attack phase [ms]|| power:| real ∈ (-inf,inf) (default = 1.5)| the power used for averaging|| releaseTime:| real ∈ [0,inf) (default = 1500)| the release time of the first order lowpass in the release phase [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm estimates the long-term loudness of an audio signal. The LARM| model is based on the asymmetrical low-pass filtering of the Peak Program| Meter (PPM), combined with Revised Low-frequency B-weighting (RLB) and power| mean calculations. LARM has shown to be a reliable and objective loudness| estimate of music and speech.|| It accepts a power parameter to define the exponential for computing the| power mean. Note that if the parameter's value is 2, this algorithm would be| equivalent to RMS and if 1, this algorithm would be the mean of the absolute| value.|| References:| [1] E. Skovenborg and S. H. Nielsen, "Evaluation of different loudness| models with music and speech material,” in The 117th AES Convention, 2004.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Leq = class Algo(Algorithm)| Leq||| Inputs:|| [vector_real] signal - the input signal (must be non-empty)||| Outputs:|| [real] leq - the equivalent sound level estimate [dB]||| Description:|| This algorithm computes the Equivalent sound level (Leq) of an audio signal.| The Leq measure can be derived from the Revised Low-frequency B-weighting| (RLB) or from the raw signal as described in [1]. If the signal contains no| energy, Leq defaults to essentias definition of silence which is -90dB.| This algorithm will throw an exception on empty input.|| References:| [1] G. A. Soulodre, "Evaluation of Objective Loudness Meters," in| The 116th AES Convention, 2004.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LevelExtractor = class Algo(Algorithm)| LevelExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] loudness - the loudness values||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 88200)| frame size to compute loudness|| hopSize:| integer ∈ (0,inf) (default = 44100)| hop size to compute loudness||| Description:|| This algorithm extracts the loudness of an audio signal in frames using| Loudness algorithm.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LogAttackTime = class Algo(Algorithm)| LogAttackTime||| Inputs:|| [vector_real] signal - the input signal envelope (must be non-empty)||| Outputs:|| [real] logAttackTime - the log (base 10) of the attack time [log10(s)]| [real] attackStart - the attack start time [s]| [real] attackStop - the attack end time [s]||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]|| startAttackThreshold:| real ∈ [0,1] (default = 0.20000000298)| the percentage of the input signal envelope at which the starting point of| the attack is considered|| stopAttackThreshold:| real ∈ [0,1] (default = 0.899999976158)| the percentage of the input signal envelope at which the ending point of| the attack is considered||| Description:|| This algorithm computes the log (base 10) of the attack time of a signal| envelope. The attack time is defined as the time duration from when the sound| becomes perceptually audible to when it reaches its maximum intensity. By| default, the start of the attack is estimated as the point where the signal| envelope reaches 20% of its maximum value in order to account for possible| noise presence. Also by default, the end of the attack is estimated as as the| point where the signal envelope has reached 90% of its maximum value, in| order to account for the possibility that the max value occurres after the| logAttack, as in trumpet sounds.|| With this said, LogAttackTime's input is intended to be fed by the output of| the Envelope algorithm. In streaming mode, the RealAccumulator algorithm| should be connected between Envelope and LogAttackTime.|| Note that startAttackThreshold cannot be greater than stopAttackThreshold and| the input signal should not be empty. In any of these cases an exception will| be thrown.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LogSpectrum = class Algo(Algorithm)| LogSpectrum||| Inputs:|| [vector_real] spectrum - spectrum frame||| Outputs:|| [vector_real] logFreqSpectrum - log frequency spectrum frame| [vector_real] meanTuning - normalized mean tuning frequency| [real] localTuning - normalized local tuning frequency||| Parameters:|| binsPerSemitone:| real ∈ (0,inf) (default = 3)| bins per semitone|| frameSize:| integer ∈ (1,inf) (default = 1025)| the input frame size of the spectrum vector|| rollOn:| real ∈ [0,5] (default = 0)| this removes low-frequency noise - useful in quiet recordings|| sampleRate:| real ∈ (0,inf) (default = 44100)| the input sample rate||| Description:|| This algorithm computes spectrum with logarithmically distributed frequency| bins. This code is ported from NNLS Chroma [1, 2].This algorithm also returns| a local tuning that is retrieved for input frame and a global tuning that is| updated with a moving average.|| Note: As the algorithm uses moving averages that are updated every frame it| should be reset before processing a new audio file. To do this call reset()| (or configure())|| References:| [1] Mauch, M., & Dixon, S. (2010, August). Approximate Note Transcription| for the Improved Identification of Difficult Chords. In ISMIR (pp.| 135-140).| [2] Chordino and NNLS Chroma,| http://www.isophonics.net/nnls-chroma|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LoopBpmConfidence = class Algo(Algorithm)| LoopBpmConfidence||| Inputs:|| [vector_real] signal - loop audio signal| [real] bpmEstimate - estimated BPM for the audio signal||| Outputs:|| [real] confidence - confidence value for the BPM estimation||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm takes an audio signal and a BPM estimate for that signal and| predicts the reliability of the BPM estimate in a value from 0 to 1. The| audio signal is assumed to be a musical loop with constant tempo. The| confidence returned is based on comparing the duration of the signal with| multiples of the BPM estimate (see [1] for more details).|| References:| [1] Font, F., & Serra, X. (2016). Tempo Estimation for Music Loops and a| Simple Confidence Measure.| Proceedings of the International Society for Music Information Retrieval| Conference (ISMIR).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm tak...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LoopBpmEstimator = class Algo(Algorithm)| LoopBpmEstimator||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] bpm - the estimated bpm (will be 0 if unsure)||| Parameters:|| confidenceThreshold:| real ∈ [0,1] (default = 0.949999988079)| confidence threshold below which bpm estimate will be considered unreliable||| Description:|| This algorithm estimates the BPM of audio loops. It internally uses| PercivalBpmEstimator algorithm to produce a BPM estimate and| LoopBpmConfidence to asses the reliability of the estimate. If the provided| estimate is below the given confidenceThreshold, the algorithm outputs a BPM| 0.0, otherwise it outputs the estimated BPM. For more details on the BPM| estimation method and the confidence measure please check the used| algorithms.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Loudness = class Algo(Algorithm)| Loudness||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] loudness - the loudness of the input signal||| Description:|| This algorithm computes the loudness of an audio signal defined by Steven's| power law. It computes loudness as the energy of the signal raised to the| power of 0.67.|| References:| [1] Energy (signal processing) - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Energy_(signal_processing)|| [2] Stevens' power law - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Stevens%27_power_law|| [3] S. S. Stevens, Psychophysics. Transaction Publishers, 1975.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LoudnessEBUR128 = class Algo(Algorithm)| LoudnessEBUR128||| Inputs:|| [vector_stereosample] signal - the input stereo audio signal||| Outputs:|| [vector_real] momentaryLoudness - momentary loudness (over 400ms) (LUFS)| [vector_real] shortTermLoudness - short-term loudness (over 3 seconds) (LUFS)| [real] integratedLoudness - integrated loudness (overall) (LUFS)| [real] loudnessRange - loudness range over an arbitrary long time interval [3] (dB, LU)||| Parameters:|| hopSize:| real ∈ (0,0.1] (default = 0.10000000149)| the hop size with which the loudness is computed [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| startAtZero:| bool ∈ {true,false} (default = false)| start momentary/short-term loudness estimation at time 0 (zero-centered| loudness estimation windows) if true; otherwise start both windows at time| 0 (time positions for momentary and short-term values will not be| syncronized)||| Description:|| This algorithm computes the EBU R128 loudness descriptors of an audio signal.|| - The input stereo signal is preprocessed with a K-weighting filter [2] (see| LoudnessEBUR128Filter algorithm), composed of two stages: a shelving filter| and a high-pass filter (RLB-weighting curve).| - Momentary loudness is computed by integrating the sum of powers over a| sliding rectangular window of 400 ms. The measurement is not gated.| - Short-term loudness is computed by integrating the sum of powers over a| sliding rectangular window of 3 seconds. The measurement is not gated.| - Integrated loudness is a loudness value averaged over an arbitrary long| time interval with gating of 400 ms blocks with two thresholds [2].| - Absolute 'silence' gating threshold at -70 LUFS for the computation of| the absolute-gated loudness level.| - Relative gating threshold, 10 LU below the absolute-gated loudness level.| - Loudness range is computed from short-term loudness values. It is defined| as the difference between the estimates of the 10th and 95th percentiles of| the distribution of the loudness values with applied gating [3].| - Absolute 'silence' gating threshold at -70 LUFS for the computation of| the absolute-gated loudness level.| - Relative gating threshold, -20 LU below the absolute-gated loudness| level.|| References:| [1] EBU Tech 3341-2011. "Loudness Metering: 'EBU Mode' metering to| supplement| loudness normalisation in accordance with EBU R 128"|| [2] ITU-R BS.1770-2. "Algorithms to measure audio programme loudness and| true-peak audio level"|| [3] EBU Tech Doc 3342-2011. "Loudness Range: A measure to supplement| loudness| normalisation in accordance with EBU R 128"|| [4] http://tech.ebu.ch/loudness|| [5] http://en.wikipedia.org/wiki/LKFS|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LoudnessVickers = class Algo(Algorithm)| LoudnessVickers||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] loudness - the Vickers loudness [dB]||| Parameters:|| sampleRate:| real ∈ [44100,44100] (default = 44100)| the audio sampling rate of the input signal which is used to create the| weight vector [Hz] (currently, this algorithm only works on signals with a| sampling rate of 44100Hz)||| Description:|| This algorithm computes Vickers's loudness of an audio signal. Currently,| this algorithm only works for signals with a 44100Hz sampling rate. This| algorithm is meant to be given frames of audio as input (not entire audio| signals). The algorithm described in the paper performs a weighted average of| the loudness value computed for each of the given frames, this step is left| as a post processing step and is not performed by this algorithm.|| References:| [1] E. Vickers, "Automatic Long-term Loudness and Dynamics Matching," in| The 111th AES Convention, 2001.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LowLevelSpectralEqloudExtractor = class Algo(Algorithm)| LowLevelSpectralEqloudExtractor||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] dissonance - See Dissonance algorithm documentation| [vector_vector_real] sccoeffs - See SpectralContrast algorithm documentation| [vector_vector_real] scvalleys - See SpectralContrast algorithm documentation| [vector_real] spectral_centroid - See Centroid algorithm documentation| [vector_real] spectral_kurtosis - See DistributionShape algorithm documentation| [vector_real] spectral_skewness - See DistributionShape algorithm documentation| [vector_real] spectral_spread - See DistributionShape algorithm documentation||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low level features|| hopSize:| integer ∈ (0,inf) (default = 1024)| the hop size for computing low level features|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate||| Description:|| This algorithm extracts a set of level spectral features for which it is| recommended to apply a preliminary equal-loudness filter over an input audio| signal (according to the internal evaluations conducted at Music Technology| Group). To this end, you are expected to provide the output of EqualLoudness| algorithm as an input for this algorithm. Still, you are free to provide an| unprocessed audio input in the case you want to compute these features| without equal-loudness filter.|| Note that at present we do not dispose any reference to justify the necessity| of equal-loudness filter. Our recommendation is grounded on internal| evaluations conducted at Music Technology Group that have shown the increase| in numeric robustness as a function of the audio encoders used (mp3, ogg,| ...) for these features.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LowLevelSpectralExtractor = class Algo(Algorithm)| LowLevelSpectralExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_vector_real] barkbands - spectral energy at each bark band. See BarkBands alogithm| [vector_real] barkbands_kurtosis - kurtosis from bark bands. See DistributionShape algorithm documentation| [vector_real] barkbands_skewness - skewness from bark bands. See DistributionShape algorithm documentation| [vector_real] barkbands_spread - spread from barkbands. See DistributionShape algorithm documentation| [vector_real] hfc - See HFC algorithm documentation| [vector_vector_real] mfcc - See MFCC algorithm documentation| [vector_real] pitch - See PitchYinFFT algorithm documentation| [vector_real] pitch_instantaneous_confidence - See PitchYinFFT algorithm documentation| [vector_real] pitch_salience - See PitchSalience algorithm documentation| [vector_real] silence_rate_20dB - See SilenceRate algorithm documentation| [vector_real] silence_rate_30dB - See SilenceRate algorithm documentation| [vector_real] silence_rate_60dB - See SilenceRate algorithm documentation| [vector_real] spectral_complexity - See Spectral algorithm documentation| [vector_real] spectral_crest - See Crest algorithm documentation| [vector_real] spectral_decrease - See Decrease algorithm documentation| [vector_real] spectral_energy - See Energy algorithm documentation| [vector_real] spectral_energyband_low - Energy in band (20,150] Hz. See EnergyBand algorithm documentation| [vector_real] spectral_energyband_middle_low - Energy in band (150,800] Hz.See EnergyBand algorithm documentation| [vector_real] spectral_energyband_middle_high - Energy in band (800,4000] Hz. See EnergyBand algorithm documentation| [vector_real] spectral_energyband_high - Energy in band (4000,20000] Hz. See EnergyBand algorithm documentation| [vector_real] spectral_flatness_db - See flatnessDB algorithm documentation| [vector_real] spectral_flux - See Flux algorithm documentation| [vector_real] spectral_rms - See RMS algorithm documentation| [vector_real] spectral_rolloff - See RollOff algorithm documentation| [vector_real] spectral_strongpeak - See StrongPeak algorithm documentation| [vector_real] zerocrossingrate - See ZeroCrossingRate algorithm documentation| [vector_real] inharmonicity - See Inharmonicity algorithm documentation| [vector_vector_real] tristimulus - See Tristimulus algorithm documentation| [vector_real] oddtoevenharmonicenergyratio - See OddToEvenHarmonicEnergyRatio algorithm documentation||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low level features|| hopSize:| integer ∈ (0,inf) (default = 1024)| the hop size for computing low level features|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate||| Description:|| This algorithm extracts all low-level spectral features, which do not require| an equal-loudness filter for their computation, from an audio signal|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).LowPass = class Algo(Algorithm)| LowPass||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| cutoffFrequency:| real ∈ (0,inf) (default = 1500)| the cutoff frequency for the filter [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm implements a 1st order IIR low-pass filter. Because of its| dependence on IIR, IIR's requirements are inherited.| References:| [1] U. Zölzer, DAFX - Digital Audio Effects, p. 40,| John Wiley & Sons, 2002|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MFCC = class Algo(Algorithm)| MFCC||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energies in mel bands| [vector_real] mfcc - the mel frequency cepstrum coefficients||| Parameters:|| dctType:| integer ∈ [2,3] (default = 2)| the DCT type|| highFrequencyBound:| real ∈ (0,inf) (default = 11000)| the upper bound of the frequency range [Hz]|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of input spectrum|| liftering:| integer ∈ [0,inf) (default = 0)| the liftering coefficient. Use '0' to bypass it|| logType:| string ∈ {natural,dbpow,dbamp,log} (default = "dbamp")| logarithmic compression type. Use 'dbpow' if working with power and 'dbamp'| if working with magnitudes|| lowFrequencyBound:| real ∈ [0,inf) (default = 0)| the lower bound of the frequency range [Hz]|| normalize:| string ∈ {unit_sum,unit_tri,unit_max} (default = "unit_sum")| spectrum bin weights to use for each mel band: 'unit_max' to make each mel| band vertex equal to 1, 'unit_sum' to make each mel band area equal to 1| summing the actual weights of spectrum bins, 'unit_area' to make each| triangle mel band area equal to 1 normalizing the weights of each triangle| by its bandwidth|| numberBands:| integer ∈ [1,inf) (default = 40)| the number of mel-bands in the filter|| numberCoefficients:| integer ∈ [1,inf) (default = 13)| the number of output mel coefficients|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| silenceThreshold:| real ∈ (0,inf) (default = 1.00000001335e-10)| silence threshold for computing log-energy bands|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum|| warpingFormula:| string ∈ {slaneyMel,htkMel} (default = "htkMel")| The scale implementation type: 'htkMel' scale from the HTK toolkit [2, 3]| (default) or 'slaneyMel' scale from the Auditory toolbox [4]|| weighting:| string ∈ {warping,linear} (default = "warping")| type of weighting function for determining triangle area||| Description:|| This algorithm computes the mel-frequency cepstrum coefficients of a| spectrum. As there is no standard implementation, the MFCC-FB40 is used by| default:| - filterbank of 40 bands from 0 to 11000Hz| - take the log value of the spectrum energy in each mel band. Bands energy| values below silence threshold will be clipped to its value before computing| log-energies| - DCT of the 40 bands down to 13 mel coefficients| There is a paper describing various MFCC implementations [1].|| The parameters of this algorithm can be configured in order to behave like| HTK [3] as follows:| - type = 'magnitude'| - warpingFormula = 'htkMel'| - weighting = 'linear'| - highFrequencyBound = 8000| - numberBands = 26| - numberCoefficients = 13| - normalize = 'unit_max'| - dctType = 3| - logType = 'log'| - liftering = 22|| In order to completely behave like HTK the audio signal has to be scaled by| 2^15 before the processing and if the Windowing and FrameCutter algorithms| are used they should also be configured as follows.|| FrameGenerator:| - frameSize = 1102| - hopSize = 441| - startFromZero = True| - validFrameThresholdRatio = 1|| Windowing:| - type = 'hamming'| - size = 1102| - zeroPadding = 946| - normalized = False|| This algorithm depends on the algorithms MelBands and DCT and therefore| inherits their parameter restrictions. An exception is thrown if any of these| restrictions are not met. The input "spectrum" is passed to the MelBands| algorithm and thus imposes MelBands' input requirements. Exceptions are| inherited by MelBands as well as by DCT.|| IDCT can be used to compute smoothed Mel Bands. In order to do this:| - compute MFCC| - smoothedMelBands = 10^(IDCT(MFCC)/20)|| Note: The second step assumes that 'logType' = 'dbamp' was used to compute| MFCCs, otherwise that formula should be changed in order to be consistent.|| References:| [1] T. Ganchev, N. Fakotakis, and G. Kokkinakis, "Comparative evaluation| of various MFCC implementations on the speaker verification task," in| International Conference on Speach and Computer (SPECOM’05), 2005,| vol. 1, pp. 191–194.|| [2] Mel-frequency cepstrum - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Mel_frequency_cepstral_coefficient|| [3] Young, S. J., Evermann, G., Gales, M. J. F., Hain, T., Kershaw, D.,| Liu, X., … Woodland, P. C. (2009). The HTK Book (for HTK Version 3.4).| Construction, (July 2000), 384, https://doi.org/http://htk.eng.cam.ac.uk|| [4] Slaney, M. Auditory Toolbox: A MATLAB Toolbox for Auditory Modeling| Work.| Technical Report, version 2, Interval Research Corporation, 1998.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Magnitude = class Algo(Algorithm)| Magnitude||| Inputs:|| [vector_complex] complex - the input vector of complex numbers||| Outputs:|| [vector_real] magnitude - the magnitudes of the input vector||| Description:|| This algorithm computes the absolute value of each element in a vector of| complex numbers.|| References:| [1] Complex Modulus -- from Wolfram MathWorld,| http://mathworld.wolfram.com/ComplexModulus.html|| [2] Complex number - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Complex_numbers#Absolute_value.2C_conjugation_a| nd_distance.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Math', 'description': 'This algorithm compu...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MaxFilter = class Algo(Algorithm)| MaxFilter||| Inputs:|| [vector_real] signal - signal to be filtered||| Outputs:|| [vector_real] signal - filtered output||| Parameters:|| causal:| bool ∈ {true,false} (default = true)| use casual filter (window is behind current element otherwise it is| centered around)|| width:| integer ∈ [2,inf) (default = 3)| the window size, has to be odd if the window is centered||| Description:|| This algorithm implements a maximum filter for 1d signal using van| Herk/Gil-Werman (HGW) algorithm.|| References:| [1] Kutil, R., and Mraz, E., Short vector SIMD parallelization of maximum| filter,| Parallel Numerics 11: 70|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MaxMagFreq = class Algo(Algorithm)| MaxMagFreq||| Inputs:|| [vector_real] spectrum - the input spectrum (must have more than 1 element)||| Outputs:|| [real] maxMagFreq - the frequency with the largest magnitude [Hz]||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the frequency with the largest magnitude in a| spectrum.| Note that a spectrum must contain at least two elements otherwise an| exception is thrown|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MaxToTotal = class Algo(Algorithm)| MaxToTotal||| Inputs:|| [vector_real] envelope - the envelope of the signal||| Outputs:|| [real] maxToTotal - the maximum amplitude position to total length ratio||| Description:|| This algorithm computes the ratio between the index of the maximum value of| the envelope of a signal and the total length of the envelope. This ratio| shows how much the maximum amplitude is off-center. Its value is close to 0| if the maximum is close to the beginning (e.g. Decrescendo or Impulsive| sounds), close to 0.5 if it is close to the middle (e.g. Delta sounds) and| close to 1 if it is close to the end of the sound (e.g. Crescendo sounds).| This algorithm is intended to be fed by the output of the Envelope algorithm|| MaxToTotal will throw an exception if the input envelope is empty.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Mean = class Algo(Algorithm)| Mean||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] mean - the mean of the input array||| Description:|| This algorithm computes the mean of an array.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Median = class Algo(Algorithm)| Median||| Inputs:|| [vector_real] array - the input array (must be non-empty)||| Outputs:|| [real] median - the median of the input array||| Description:|| This algorithm computes the median of an array. When there is an odd number| of numbers, the median is simply the middle number. For example, the median| of 2, 4, and 7 is 4. When there is an even number of numbers, the median is| the mean of the two middle numbers. Thus, the median of the numbers 2, 4, 7,| 12 is (4+7)/2 = 5.5. See [1] for more info.|| References:| [1] Statistical Median -- from Wolfram MathWorld,| http://mathworld.wolfram.com/StatisticalMedian.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MedianFilter = class Algo(Algorithm)| MedianFilter||| Inputs:|| [vector_real] array - the input array (must be non-empty)||| Outputs:|| [vector_real] filteredArray - the median-filtered input array||| Parameters:|| kernelSize:| integer ∈ [1,inf) (default = 11)| scalar giving the size of the median filter window. Must be odd||| Description:|| This algorithm computes the median filtered version of the input signal| giving the kernel size as detailed in [1].|| References:| [1] Median Filter -- from Wikipedia.org,| https://en.wikipedia.org/wiki/Median_filter|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm co...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MelBands = class Algo(Algorithm)| MelBands||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energy in mel bands||| Parameters:|| highFrequencyBound:| real ∈ [0,inf) (default = 22050)| an upper-bound limit for the frequencies to be included in the bands|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of the spectrum|| log:| bool ∈ {true,false} (default = false)| compute log-energies (log10 (1 + energy))|| lowFrequencyBound:| real ∈ [0,inf) (default = 0)| a lower-bound limit for the frequencies to be included in the bands|| normalize:| string ∈ {unit_sum,unit_tri,unit_max} (default = "unit_sum")| spectrum bin weights to use for each mel band: 'unit_max' to make each mel| band vertex equal to 1, 'unit_sum' to make each mel band area equal to 1| summing the actual weights of spectrum bins, 'unit_area' to make each| triangle mel band area equal to 1 normalizing the weights of each triangle| by its bandwidth|| numberBands:| integer ∈ (1,inf) (default = 24)| the number of output bands|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sample rate|| type:| string ∈ {magnitude,power} (default = "power")| 'power' to output squared units, 'magnitude' to keep it as the input|| warpingFormula:| string ∈ {slaneyMel,htkMel} (default = "htkMel")| The scale implementation type: 'htkMel' scale from the HTK toolkit [2, 3]| (default) or 'slaneyMel' scale from the Auditory toolbox [4]|| weighting:| string ∈ {warping,linear} (default = "warping")| type of weighting function for determining triangle area||| Description:|| This algorithm computes energy in mel bands of a spectrum. It applies a| frequency-domain filterbank (MFCC FB-40, [1]), which consists of equal area| triangular filters spaced according to the mel scale. The filterbank is| normalized in such a way that the sum of coefficients for every filter equals| one. It is recommended that the input "spectrum" be calculated by the| Spectrum algorithm.|| It is required that parameter "highMelFrequencyBound" not be larger than the| Nyquist frequency, but must be larger than the parameter,| "lowMelFrequencyBound". Also, The input spectrum must contain at least two| elements. If any of these requirements are violated, an exception is thrown.|| Note: an exception will be thrown in the case when the number of spectrum| bins (FFT size) is insufficient to compute the specified number of mel bands:| in such cases the start and end bin of a band can be the same bin or adjacent| bins, which will result in zero energy when summing bins for that band. Use| zero padding to increase the number of spectrum bins in these cases.|| References:| [1] T. Ganchev, N. Fakotakis, and G. Kokkinakis, "Comparative evaluation| of various MFCC implementations on the speaker verification task," in| International Conference on Speach and Computer (SPECOM’05), 2005,| vol. 1, pp. 191–194.|| [2] Mel-frequency cepstrum - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Mel_frequency_cepstral_coefficient|| [3] Young, S. J., Evermann, G., Gales, M. J. F., Hain, T., Kershaw, D.,| Liu, X., … Woodland, P. C. (2009). The HTK Book (for HTK Version 3.4).| Construction, (July 2000), 384, https://doi.org/http://htk.eng.cam.ac.uk|| [4] Slaney, M. Auditory Toolbox: A MATLAB Toolbox for Auditory Modeling| Work.| Technical Report, version 2, Interval Research Corporation, 1998.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MetadataReader = class Algo(Algorithm)| MetadataReader||| Outputs:|| [string] title - the title of the track| [string] artist - the artist of the track| [string] album - the album on which this track appears| [string] comment - the comment field stored in the tags| [string] genre - the genre as stored in the tags| [string] tracknumber - the track number| [string] date - the date of publication| [pool] tagPool - the pool with all tags that were found| [integer] duration - the duration of the track, in seconds| [integer] bitrate - the bitrate of the track [kb/s]| [integer] sampleRate - the sample rate [Hz]| [integer] channels - the number of channels||| Parameters:|| failOnError:| bool ∈ {true,false} (default = false)| if true, the algorithm throws an exception when encountering an error (e.g.| trying to open an unsupported file format), otherwise the algorithm leaves| all fields blank|| filename:| string| the name of the file from which to read the tags|| filterMetadata:| bool (default = false)| if true, only add tags from filterMetadataTags to the pool|| filterMetadataTags:| vector_string (default = [])| the list of tags to whitelist (original taglib names)|| tagPoolName:| string (default = "metadata.tags")| common prefix for tag descriptor names to use in tagPool||| Description:|| This algorithm loads the metadata tags from an audio file as well as outputs| its audio properties. Supported audio file types are:| - mp3| - flac| - ogg| An exception is thrown if unsupported filetype is given or if the file does| not exist.| Please observe that the .wav format is not supported. Also note that this| algorithm incorrectly calculates the number of channels for a file in mp3| format only for versions less than 1.5 of taglib in Linux and less or equal| to 1.5 in Mac OS X| If using this algorithm on Windows, you must ensure that the filename is| encoded as UTF-8.| This algorithm also contains some heuristic to try to deal with encoding| errors in the tags and tries to do the appropriate conversion if a problem| was found (mostly twice latin1->utf8 conversion).|| MetadataReader reads all metadata tags found in audio and stores them in the| pool tagPool. Standard metadata tags found in audio files include strings| mentioned in [1,2]. Tag strings are case-sensitive and they are converted to| lower-case when stored to the pool. It is possible to filter these tags by| using 'filterMetadataTags' parameter. This parameter should specify a| white-list of tag strings as they are found in the audio file (e.g.,| "ARTIST").|| References:| [1] https://taglib.github.io/api/classTagLib_1_1PropertyMap.html#details|| [2] https://picard.musicbrainz.org/docs/mappings/|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Meter = class Algo(Algorithm)| Meter||| Inputs:|| [vector_vector_real] beatogram - filtered matrix loudness||| Outputs:|| [real] meter - the time signature||| Description:|| This algorithm estimates the time signature of a given beatogram by finding| the highest correlation between beats.|| Quality: experimental (not evaluated, do not use)|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MinMax = class Algo(Algorithm)| MinMax||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] real - the minimum or maximum of the input array, according to the type parameter| [integer] int - the index of the value||| Parameters:|| type:| string ∈ {min,max} (default = "min")| the type of the operation||| Description:|| This algorithm calculates the minimum or maximum value of an array.| If the array has more than one minimum or maximum value, the index of the| first one is returned|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MinToTotal = class Algo(Algorithm)| MinToTotal||| Inputs:|| [vector_real] envelope - the envelope of the signal||| Outputs:|| [real] minToTotal - the minimum amplitude position to total length ratio||| Description:|| This algorithm computes the ratio between the index of the minimum value of| the envelope of a signal and the total length of the envelope.|| An exception is thrown if the input envelop is empty.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MonoLoader = class Algo(Algorithm)| MonoLoader||| Outputs:|| [vector_real] audio - the audio signal||| Parameters:|| audioStream:| integer ∈ [0,inf) (default = 0)| audio stream index to be loaded. Other streams are no taken into account| (e.g. if stream 0 is video and 1 is audio use index 0 to access it.)|| downmix:| string ∈ {left,right,mix} (default = "mix")| the mixing type for stereo files|| filename:| string| the name of the file from which to read|| sampleRate:| real ∈ (0,inf) (default = 44100)| the desired output sampling rate [Hz]||| Description:|| This algorithm loads the raw audio data from an audio file and downmixes it| to mono. Audio is resampled in case the given sampling rate does not match| the sampling rate of the input signal.|| This algorithm uses AudioLoader and thus inherits all of its input| requirements and exceptions.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MonoMixer = class Algo(Algorithm)| MonoMixer||| Inputs:|| [vector_stereosample] audio - the input stereo signal| [integer] numberChannels - the number of channels of the input signal||| Outputs:|| [vector_real] audio - the downmixed signal||| Parameters:|| type:| string ∈ {left,right,mix} (default = "mix")| the type of downmixing performed||| Description:|| This algorithm downmixes the signal into a single channel given a stereo| signal. If the signal was already a monoaural, it is left unchanged.|| References:| [1] downmixing - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Downmixing|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm d...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MonoWriter = class Algo(Algorithm)| MonoWriter||| Inputs:|| [vector_real] audio - the audio signal||| Parameters:|| bitrate:| integer ∈ {32,40,48,56,64,80,96,112,128,144,160,192,224,256,320} (default = 192)| the audio bit rate for compressed formats [kbps]|| filename:| string| the name of the encoded file|| format:| string ∈ {wav,aiff,mp3,ogg,flac} (default = "wav")| the audio output format|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm writes a mono audio stream to a file.|| The algorithm uses FFmpeg. Supported formats are wav, aiff, mp3, flac and| ogg. An exception is thrown when other extensions are given. The default| FFmpeg encoders are used for each format. Note that to encode in mp3 format| it is mandatory that FFmpeg was configured with mp3 enabled.|| If the file specified by filename could not be opened or the header of the| file omits channel's information, an exception is thrown.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': "This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MovingAverage = class Algo(Algorithm)| MovingAverage||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the filtered signal||| Parameters:|| size:| integer ∈ (1,inf) (default = 6)| the size of the window [audio samples]||| Description:|| This algorithm implements a FIR Moving Average filter. Because of its| dependece on IIR, IIR's requirements are inherited.|| References:| [1] Moving Average Filters, http://www.dspguide.com/ch15.htm|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Filters', 'description': 'This algorithm im...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MultiPitchKlapuri = class Algo(Algorithm)| MultiPitchKlapuri||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_vector_real] pitch - the estimated pitch values [Hz]||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing pitch saliecnce|| harmonicWeight:| real ∈ (0,1) (default = 0.800000011921)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter for the salience function (=0 for maximum| compression, =1 for no compression)|| magnitudeThreshold:| integer ∈ [0,inf) (default = 40)| spectral peak magnitude threshold (maximum allowed difference from the| highest peak in dBs)|| maxFrequency:| real ∈ [0,inf) (default = 1760)| the maximum allowed frequency for salience function peaks (ignore peaks| above) [Hz]|| minFrequency:| real ∈ [0,inf) (default = 80)| the minimum allowed frequency for salience function peaks (ignore peaks| below) [Hz]|| numberHarmonics:| integer ∈ [1,inf) (default = 10)| number of considered harmonics|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm estimates multiple pitch values corresponding to the melodic| lines present in a polyphonic music signal (for example, string quartet,| piano). This implementation is based on the algorithm in [1]: In each frame,| a set of possible fundamental frequency candidates is extracted based on the| principle of harmonic summation. In an optimization stage, the number of| harmonic sources (polyphony) is estimated and the final set of fundamental| frequencies determined. In contrast to the pich salience function proposed in| [2], this implementation uses the pitch salience function described in [1].| The output is a vector for each frame containing the estimated melody pitch| values.|| References:| [1] A. Klapuri, "Multiple Fundamental Frequency Estimation by Summing| Harmonic| Amplitudes ", International Society for Music Information Retrieval| Conference| (2006).| [2] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MultiPitchMelodia = class Algo(Algorithm)| MultiPitchMelodia||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_vector_real] pitch - the estimated pitch values [Hz]||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of iterations for the octave errors / pitch outlier filtering| process|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing pitch saliecnce|| guessUnvoiced:| bool ∈ {false,true} (default = false)| estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| harmonicWeight:| real ∈ (0,1) (default = 0.800000011921)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter for the salience function (=0 for maximum| compression, =1 for no compression)|| magnitudeThreshold:| integer ∈ [0,inf) (default = 40)| spectral peak magnitude threshold (maximum allowed difference from the| highest peak in dBs)|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minDuration:| integer ∈ (0,inf) (default = 100)| the minimum allowed contour duration [ms]|| minFrequency:| real ∈ [0,inf) (default = 40)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| numberHarmonics:| integer ∈ [1,inf) (default = 20)| number of considered harmonics|| peakDistributionThreshold:| real ∈ [0,2] (default = 0.899999976158)| allowed deviation below the peak salience mean over all frames (fraction of| the standard deviation)|| peakFrameThreshold:| real ∈ [0,1] (default = 0.899999976158)| per-frame salience threshold factor (fraction of the highest peak salience| in a frame)|| pitchContinuity:| real ∈ [0,inf) (default = 27.5625)| pitch continuity cue (maximum allowed pitch change during 1 ms time period)| [cents]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| timeContinuity:| integer ∈ (0,inf) (default = 100)| time continuity cue (the maximum allowed gap duration for a pitch contour)| [ms]||| Description:|| This algorithm estimates multiple fundamental frequency contours from an| audio signal. It is a multi pitch version of the MELODIA algorithm described| in [1]. While the algorithm is originally designed to extract melody in| polyphonic music, this implementation is adapted for multiple sources. The| approach is based on the creation and characterization of pitch contours,| time continuous sequences of pitch candidates grouped using auditory| streaming cues. To this end, PitchSalienceFunction,| PitchSalienceFunctionPeaks, PitchContours, and PitchContoursMonoMelody| algorithms are employed. It is strongly advised to use the default parameter| values which are optimized according to [1] (where further details are| provided) except for minFrequency, maxFrequency, and voicingTolerance, which| will depend on your application.|| The output is a vector of estimated melody pitch values and a vector of| confidence values.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| [2] http://mtg.upf.edu/technologies/melodia|| [3] http://www.justinsalamon.com/melody-extraction|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Multiplexer = class Algo(Algorithm)| Multiplexer||| Outputs:|| [vector_vector_real] data - the frame containing the input values and/or input frames||| Parameters:|| numberRealInputs:| integer ∈ [0,inf) (default = 0)| the number of inputs of type Real to multiplex|| numberVectorRealInputs:| integer ∈ [0,inf) (default = 0)| the number of inputs of type vector<Real> to multiplex||| Description:|| This algorithm returns a single vector from a given number of real values| and/or frames. Frames from different inputs are multiplexed onto a single| stream in an alternating fashion.|| This algorithm throws an exception if the number of input reals (or| vector<real>) is less than the number specified in configuration parameters| or if the user tries to acces an input which has not been specified.|| References:| [1] Multiplexer - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Multiplexer|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm r...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MusicExtractor = class Algo(Algorithm)| MusicExtractor||| Inputs:|| [string] filename - the input audiofile||| Outputs:|| [pool] results - Analysis results pool with across-frames statistics| [pool] resultsFrames - Analysis results pool with computed frame values||| Parameters:|| analysisSampleRate:| real ∈ (0,inf) (default = 44100)| the analysis sampling rate of the audio signal [Hz]|| chromaprintCompute:| bool ∈ {true,false} (default = false)| compute the Chromaprint|| chromaprintDuration:| real ∈ [0,inf) (default = 0)| the amount of time from the beginning used to compute the Chromaprint. 0 to| use the full audio length [s]|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice you want to extract [s]|| gfccStats:| vector_string (default = ["mean", "cov", "icov"])| the statistics to compute for GFCC features|| highlevel:| vector_string| list of high-level classifier models (gaia2 history filenames) to apply| using extracted features. Skip classification if not specified (empty list)|| loudnessFrameSize:| integer ∈ (0,inf) (default = 88200)| the frame size for computing average loudness|| loudnessHopSize:| integer ∈ (0,inf) (default = 44100)| the hop size for computing average loudness|| lowlevelFrameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low-level features|| lowlevelHopSize:| integer ∈ (0,inf) (default = 1024)| the hop size for computing low-level features|| lowlevelSilentFrames:| string ∈ {drop,keep,noise} (default = "noise")| whether to [keep/drop/add noise to] silent frames for computing low-level| features|| lowlevelStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for low-level features|| lowlevelWindowType:| string ∈ {hamming,hann,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "blackmanharris62")| the window type for computing low-level features|| lowlevelZeroPadding:| integer ∈ [0,inf) (default = 0)| zero padding factor for computing low-level features|| mfccStats:| vector_string (default = ["mean", "cov", "icov"])| the statistics to compute for MFCC features|| profile:| string| profile filename. If specified, default parameter values are overwritten by| values in the profile yaml file. If not specified (empty string), use| values configured by user like in other normal algorithms|| requireMbid:| bool ∈ {true,false} (default = false)| ignore audio files without musicbrainz recording id tag (throw exception)|| rhythmMaxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| rhythmMethod:| string ∈ {multifeature,degara} (default = "degara")| the method used for beat tracking|| rhythmMinTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]|| rhythmStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for rhythm features|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice you want to extract [s]|| tonalFrameSize:| integer ∈ (0,inf) (default = 4096)| the frame size for computing tonal features|| tonalHopSize:| integer ∈ (0,inf) (default = 2048)| the hop size for computing tonal features|| tonalSilentFrames:| string ∈ {drop,keep,noise} (default = "noise")| whether to [keep/drop/add noise to] silent frames for computing tonal| features|| tonalStats:| vector_string (default = ["mean", "var", "stdev", "median", "min", "max", "dmean", "dmean2", "dvar", "dvar2"])| the statistics to compute for tonal features|| tonalWindowType:| string ∈ {hamming,hann,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "blackmanharris62")| the window type for computing tonal features|| tonalZeroPadding:| integer ∈ [0,inf) (default = 0)| zero padding factor for computing tonal features||| Description:|| This algorithm is a wrapper for Music Extractor. See documentation for| 'essentia_streaming_extractor_music'.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': "This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).MusicExtractorSVM = class Algo(Algorithm)| MusicExtractorSVM||| Inputs:|| [pool] pool - aggregated pool of extracted values||| Outputs:|| [pool] pool - pool with classification results (resulting from the transformation of the gaia point)||| Parameters:|| svms:| vector_string| list of svm models (gaia2 history) filenames.||| Description:|| This algorithms computes SVM predictions given a pool with aggregated| descriptor values computed by MusicExtractor.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Extractors', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NNLSChroma = class Algo(Algorithm)| NNLSChroma||| Inputs:|| [vector_vector_real] logSpectrogram - log spectrum frames| [vector_real] meanTuning - mean tuning frames| [vector_real] localTuning - local tuning frames||| Outputs:|| [vector_vector_real] tunedLogfreqSpectrum - Log frequency spectrum after tuning| [vector_vector_real] semitoneSpectrum - a spectral representation with one bin per semitone| [vector_vector_real] bassChromagram - a 12-dimensional chromagram, restricted to the bass range| [vector_vector_real] chromagram - a 12-dimensional chromagram, restricted with mid-range emphasis||| Parameters:|| chromaNormalization:| string ∈ {none,maximum,L1,L2} (default = "none")| determines whether or how the chromagrams are normalised|| frameSize:| integer ∈ (1,inf) (default = 1025)| the input frame size of the spectrum vector|| sampleRate:| real ∈ (0,inf) (default = 44100)| the input sample rate|| spectralShape:| real ∈ (0.5,0.9) (default = 0.699999988079)| the shape of the notes in the NNLS dictionary|| spectralWhitening:| real ∈ [0,1.0] (default = 1)| determines how much the log-frequency spectrum is whitened|| tuningMode:| string ∈ {global,local} (default = "global")| local uses a local average for tuning, global uses all audio frames. Local| tuning is only advisable when the tuning is likely to change over the audio|| useNNLS:| bool ∈ {true,false} (default = true)| toggle between NNLS approximate transcription and linear spectral mapping||| Description:|| This algorithm extracts treble and bass chromagrams from a sequence of| log-frequency spectrum frames.| On this representation, two processing steps are performed:| -tuning, after which each centre bin (i.e. bin 2, 5, 8, ...) corresponds to| a semitone, even if the tuning of the piece deviates from 440 Hz standard| pitch.| -running standardisation: subtraction of the running mean, division by the| running standard deviation. This has a spectral whitening effect.| This code is ported from NNLS Chroma [1, 2]. To achieve similar results| follow this processing chain:| frame slicing with sample rate = 44100, frame size = 16384, hop size = 2048| -> Windowing with Hann and no normalization -> Spectrum -> LogSpectrum.|| References:| [1] Mauch, M., & Dixon, S. (2010, August). Approximate Note Transcription| for the Improved Identification of Difficult Chords. In ISMIR (pp.| 135-140).| [2] Chordino and NNLS Chroma,| http://www.isophonics.net/nnls-chroma|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm extr...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NSGConstantQ = class Algo(Algorithm)| NSGConstantQ||| Inputs:|| [vector_real] frame - the input frame (vector)||| Outputs:|| [vector_vector_complex] constantq - the constant Q transform of the input frame| [vector_complex] constantqdc - the DC band transform of the input frame. Only needed for the inverse transform| [vector_complex] constantqnf - the Nyquist band transform of the input frame. Only needed for the inverse transform||| Parameters:|| binsPerOctave:| integer ∈ [1,inf) (default = 48)| the number of bins per octave|| gamma:| integer ∈ [0,inf) (default = 0)| The bandwidth of each filter is given by Bk = 1/Q * fk + gamma|| inputSize:| integer ∈ (0,inf) (default = 4096)| the size of the input|| maxFrequency:| real ∈ (0,inf) (default = 7040)| the maximum frequency|| minFrequency:| real ∈ (0,inf) (default = 27.5)| the minimum frequency|| minimumWindow:| integer ∈ [2,inf) (default = 4)| minimum size allowed for the windows|| normalize:| string ∈ {sine,impulse,none} (default = "none")| coefficient normalization|| phaseMode:| string ∈ {local,global} (default = "global")| 'local' to use zero-centered filters. 'global' to use a phase mapping| function as described in [1]|| rasterize:| string ∈ {none,full,piecewise} (default = "full")| hop sizes for each frequency channel. With 'none' each frequency channel is| distinct. 'full' sets the hop sizes of all the channels to the smallest.| 'piecewise' rounds down the hop size to a power of two|| sampleRate:| real ∈ [0,inf) (default = 44100)| the desired sampling rate [Hz]|| window:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hannnsgcq")| the type of window for the frequency filters. It is not recommended to| change the default window.|| windowSizeFactor:| integer ∈ [1,inf) (default = 1)| window sizes are rounded to multiples of this||| Description:|| This algorithm computes a constant Q transform using non stationary Gabor| frames and returns a complex time-frequency representation of the input| vector.| The implementation is inspired by the toolbox described in [1].| References:| [1] Schörkhuber, C., Klapuri, A., Holighaus, N., & Dörfler, M. (n.d.). A| Matlab Toolbox for Efficient Perfect Reconstruction Time-Frequency Transforms| with Log-Frequency Resolution.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NSGIConstantQ = class Algo(Algorithm)| NSGIConstantQ||| Inputs:|| [vector_vector_complex] constantq - the constant Q transform of the input frame| [vector_complex] constantqdc - the DC band transform of the input frame| [vector_complex] constantqnf - the Nyquist band transform of the input frame||| Outputs:|| [vector_real] frame - the input frame (vector)||| Parameters:|| binsPerOctave:| integer ∈ [1,inf) (default = 48)| the number of bins per octave|| gamma:| integer ∈ [0,inf) (default = 0)| The bandwidth of each filter is given by Bk = 1/Q * fk + gamma|| inputSize:| integer ∈ (0,inf) (default = 4096)| the size of the input|| maxFrequency:| real ∈ (0,inf) (default = 7040)| the maximum frequency|| minFrequency:| real ∈ (0,inf) (default = 27.5)| the minimum frequency|| minimumWindow:| integer ∈ [2,inf) (default = 4)| minimum size allowed for the windows|| normalize:| string ∈ {sine,impulse,none} (default = "none")| coefficient normalization|| phaseMode:| string ∈ {local,global} (default = "global")| 'local' to use zero-centered filters. 'global' to use a phase mapping| function as described in [1]|| rasterize:| string ∈ {none,full,piecewise} (default = "full")| hop sizes for each frequency channel. With 'none' each frequency channel is| distinct. 'full' sets the hop sizes of all the channels to the smallest.| 'piecewise' rounds down the hop size to a power of two|| sampleRate:| real ∈ [0,inf) (default = 44100)| the desired sampling rate [Hz]|| window:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hannnsgcq")| the type of window for the frequency filters. It is not recommended to| change the default window.|| windowSizeFactor:| integer ∈ [1,inf) (default = 1)| window sizes are rounded to multiples of this||| Description:|| This algorithm computes an inverse constant Q transform using non stationary| Gabor frames and returns a complex time-frequency representation of the input| vector.| The implementation is inspired by the toolbox described in [1].| References:| [1] Schörkhuber, C., Klapuri, A., Holighaus, N., & Dörfler, M. (n.d.). A| Matlab Toolbox for Efficient Perfect Reconstruction Time-Frequency Transforms| with Log-Frequency Resolution.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NoiseAdder = class Algo(Algorithm)| NoiseAdder||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the output signal with the added noise||| Parameters:|| fixSeed:| bool ∈ {true,false} (default = false)| if true, 0 is used as the seed for generating random values|| level:| integer ∈ (-inf,0] (default = -100)| power level of the noise generator [dB]||| Description:|| This algorithm adds noise to an input signal. The average energy of the noise| in dB is defined by the level parameter, and is generated using the Mersenne| Twister random number generator.|| References:| [1] Mersenne Twister: A random number generator (since 1997/10),| http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html|| [2] Mersenne twister - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Mersenne_twister|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm a...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NoiseBurstDetector = class Algo(Algorithm)| NoiseBurstDetector||| Inputs:|| [vector_real] frame - the input frame (must be non-empty)||| Outputs:|| [vector_real] indexes - indexes of the noisy samples||| Parameters:|| alpha:| real ∈ (0,1) (default = 0.899999976158)| alpha coefficient for the Exponential Moving Average threshold estimation.|| silenceThreshold:| integer ∈ (-inf,0) (default = -50)| threshold to skip silent frames|| threshold:| integer ∈ (-inf,inf) (default = 8)| factor to control the dynamic theshold||| Description:|| This algorithm detects noise bursts in the waveform by thresholding the| peaks of the second derivative. The threshold is computed using an| Exponential Moving Average filter over the RMS of the second derivative of| the input frame.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NoveltyCurve = class Algo(Algorithm)| NoveltyCurve||| Inputs:|| [vector_vector_real] frequencyBands - the frequency bands||| Outputs:|| [vector_real] novelty - the novelty curve as a single vector||| Parameters:|| frameRate:| real ∈ [1,inf) (default = 344.53125)| the sampling rate of the input audio|| normalize:| bool ∈ {true,false} (default = false)| whether to normalize each band's energy|| weightCurve:| vector_real (default = [])| vector containing the weights for each frequency band. Only if| weightCurveType==supplied|| weightCurveType:| string ∈ {flat,triangle,inverse_triangle,parabola,inverse_parabola,linear,quadratic,inverse_quadratic,hybrid,supplied} (default = "hybrid")| the type of weighting to be used for the bands novelty||| Description:|| This algorithm computes the "novelty curve" (Grosche & Müller, 2009) onset| detection function. The algorithm expects as an input a frame-wise sequence| of frequency-bands energies or spectrum magnitudes as originally proposed in| [1] (see FrequencyBands and Spectrum algorithms). Novelty in each band (or| frequency bin) is computed as a derivative between log-compressed energy| (magnitude) values in consequent frames. The overall novelty value is then| computed as a weighted sum that can be configured using 'weightCurve'| parameter. The resulting novelty curve can be used for beat tracking and| onset detection (see BpmHistogram and Onsets).|| Notes:| - Recommended frame/hop size for spectrum computation is 2048/1024 samples| (44.1 kHz sampling rate) [2].| - Log compression is applied with C=1000 as in [1].| - Frequency bands energies (see FrequencyBands) as well as bin magnitudes for| the whole spectrum can be used as an input. The implementation for the| original algorithm [2] works with spectrum bin magnitudes for which novelty| functions are computed separately and are then summarized into bands.| - In the case if 'weightCurve' is set to 'hybrid' a complex combination of| flat, quadratic, linear and inverse quadratic weight curves is used. It was| reported to improve performance of beat tracking in some informal in-house| experiments (Note: this information is probably outdated).|| References:| [1] P. Grosche and M. Müller, "A mid-level representation for capturing| dominant tempo and pulse information in music recordings," in| International Society for Music Information Retrieval Conference| (ISMIR’09), 2009, pp. 189–194.| [2] Tempogram Toolbox (Matlab implementation),| http://resources.mpi-inf.mpg.de/MIR/tempogramtoolbox|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).NoveltyCurveFixedBpmEstimator = class Algo(Algorithm)| NoveltyCurveFixedBpmEstimator||| Inputs:|| [vector_real] novelty - the novelty curve of the audio signal||| Outputs:|| [vector_real] bpms - the bpm candidates sorted by magnitude| [vector_real] amplitudes - the magnitude of each bpm candidate||| Parameters:|| hopSize:| integer (default = 512)| the hopSize used to computeh the novelty curve from the original signal|| maxBpm:| real ∈ (0,inf) (default = 560)| the maximum bpm to look for|| minBpm:| real ∈ (0,inf) (default = 30)| the minimum bpm to look for|| sampleRate:| real ∈ [1,inf) (default = 44100)| the sampling rate original audio signal [Hz]|| tolerance:| real ∈ (0,100] (default = 3)| tolerance (in percentage) for considering bpms to be equal||| Description:|| This algorithm outputs a histogram of the most probable bpms assuming the| signal has constant tempo given the novelty curve. This algorithm is based on| the autocorrelation of the novelty curve (see NoveltyCurve algorithm) and| should only be used for signals that have a constant tempo or as a first| tempo estimator to be used in conjunction with other algorithms such as| BpmHistogram.It is a simplified version of the algorithm described in [1] as,| in order to predict the best BPM candidate, it computes autocorrelation of| the entire novelty curve instead of analyzing it on frames and histogramming| the peaks over frames.|| References:| [1] E. Aylon and N. Wack, "Beat detection using plp," in Music Information| Retrieval Evaluation Exchange (MIREX’10), 2010.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm out...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).OddToEvenHarmonicEnergyRatio = class Algo(Algorithm)| OddToEvenHarmonicEnergyRatio||| Inputs:|| [vector_real] frequencies - the frequencies of the harmonic peaks (at least two frequencies in frequency ascending order)| [vector_real] magnitudes - the magnitudes of the harmonic peaks (at least two magnitudes in frequency ascending order)||| Outputs:|| [real] oddToEvenHarmonicEnergyRatio - the ratio between the odd and even harmonic energies of the given harmonic peaks||| Description:|| This algorithm computes the ratio between a signal's odd and even harmonic| energy given the signal's harmonic peaks. The odd to even harmonic energy| ratio is a measure allowing to distinguish odd-harmonic-energy predominant| sounds (such as from a clarinet) from equally important even-harmonic-energy| sounds (such as from a trumpet). The required harmonic frequencies and| magnitudes can be computed by the HarmonicPeaks algorithm.| In the case when the even energy is zero, which may happen when only even| harmonics where found or when only one peak was found, the algorithm outputs| the maximum real number possible. Therefore, this algorithm should be used in| conjunction with the harmonic peaks algorithm.| If no peaks are supplied, the algorithm outputs a value of one, assuming| either the spectrum was flat or it was silent.|| An exception is thrown if the input frequency and magnitude vectors have| different size. Finally, an exception is thrown if the frequency and| magnitude vectors are not ordered by ascending frequency.|| References:| [1] K. D. Martin and Y. E. Kim, "Musical instrument identification:| A pattern-recognition approach," The Journal of the Acoustical Society of| America, vol. 104, no. 3, pp. 1768–1768, 1998.|| [2] K. Ringgenberg et al., "Musical Instrument Recognition,"| http://cnx.org/content/col10313/1.3/pdf|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).OnsetDetection = class Algo(Algorithm)| OnsetDetection||| Inputs:|| [vector_real] spectrum - the input spectrum| [vector_real] phase - the phase vector corresponding to this spectrum (used only by the "complex" method)||| Outputs:|| [real] onsetDetection - the value of the detection function in the current frame||| Parameters:|| method:| string ∈ {hfc,complex,complex_phase,flux,melflux,rms} (default = "hfc")| the method used for onset detection|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes various onset detection functions. The output of this| algorithm should be post-processed in order to determine whether the frame| contains an onset or not. Namely, it could be fed to the Onsets algorithm. It| is recommended that the input "spectrum" is generated by the Spectrum| algorithm.| Four methods are available:| - 'HFC', the High Frequency Content detection function which accurately| detects percussive events (see HFC algorithm for details).| - 'complex', the Complex-Domain spectral difference function [1] taking| into account changes in magnitude and phase. It emphasizes note onsets either| as a result of significant change in energy in the magnitude spectrum, and/or| a deviation from the expected phase values in the phase spectrum, caused by a| change in pitch.| - 'complex_phase', the simplified Complex-Domain spectral difference| function [2] taking into account phase changes, weighted by magnitude.| TODO:It reacts better on tonal sounds such as bowed string, but tends to| over-detect percussive events.| - 'flux', the Spectral Flux detection function which characterizes changes| in magnitude spectrum. See Flux algorithm for details.| - 'melflux', the spectral difference function, similar to spectral flux,| but using half-rectified energy changes in Mel-frequency bands of the| spectrum [3].| - 'rms', the difference function, measuring the half-rectified change of| the RMS of the magnitude spectrum (i.e., measuring overall energy flux) [4].|| If using the 'HFC' detection function, make sure to adhere to HFC's input| requirements when providing an input spectrum. Input vectors of different| size or empty input spectra will raise exceptions.| If using the 'complex' detection function, suggested parameters for| computation of "spectrum" and "phase" are 44100Hz sample rate, frame size of| 1024 and hopSize of 512 samples, which results in a resolution of 11.6ms, and| a Hann window.|| References:| [1] Bello, Juan P., Chris Duxbury, Mike Davies, and Mark Sandler, On the| use of phase and energy for musical onset detection in the complex domain,| Signal Processing Letters, IEEE 11, no. 6 (2004): 553-556.|| [2] P. Brossier, J. P. Bello, and M. D. Plumbley, "Fast labelling of notes| in music signals," in International Symposium on Music Information| Retrieval (ISMIR’04), 2004, pp. 331–336.|| [3] D. P. W. Ellis, "Beat Tracking by Dynamic Programming," Journal of| New Music Research, vol. 36, no. 1, pp. 51–60, 2007.|| [4] J. Laroche, "Efficient Tempo and Beat Tracking in Audio Recordings,"| JAES, vol. 51, no. 4, pp. 226–233, 2003.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).OnsetDetectionGlobal = class Algo(Algorithm)| OnsetDetectionGlobal||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] onsetDetections - the frame-wise values of the detection function||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing onset detection function|| hopSize:| integer ∈ (0,inf) (default = 512)| the hop size for computing onset detection function|| method:| string ∈ {infogain,beat_emphasis} (default = "infogain")| the method used for onset detection|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes various onset detection functions. Detection values| are computed frame-wisely given an input signal. The output of this algorithm| should be post-processed in order to determine whether the frame contains an| onset or not. Namely, it could be fed to the Onsets algorithm.| The following method are available:| - 'infogain', the spectral difference measured by the modified information| gain [1]. For each frame, it accounts for energy change in between preceding| and consecutive frames, histogrammed together, in order to suppress| short-term variations on frame-by-frame basis.| - 'beat_emphasis', the beat emphasis function [1]. This function is a| linear combination of onset detection functions (complex spectral| differences) in a number of sub-bands, weighted by their beat strength| computed over the entire input signal.| Note:| - 'infogain' onset detection has been optimized for the default| sampleRate=44100Hz, frameSize=2048, hopSize=512.| - 'beat_emphasis' is optimized for a fixed resolution of 11.6ms, which| corresponds to the default sampleRate=44100Hz, frameSize=1024, hopSize=512.| Optimal performance of beat detection with TempoTapDegara is not guaranteed| for other settings.|| References:| [1] S. Hainsworth and M. Macleod, "Onset detection in musical audio| signals," in International Computer Music Conference (ICMC’03), 2003,| pp. 163–6.|| [2] M. E. P. Davies, M. D. Plumbley, and D. Eck, "Towards a musical beat| emphasis function," in IEEE Workshop on Applications of Signal Processing| to Audio and Acoustics, 2009. WASPAA ’09, 2009, pp. 61–64.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).OnsetRate = class Algo(Algorithm)| OnsetRate||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] onsets - the positions of detected onsets [s]| [real] onsetRate - the number of onsets per second||| Description:|| This algorithm computes the number of onsets per second and their position in| time for an audio signal. Onset detection functions are computed using both| high frequency content and complex-domain methods available in OnsetDetection| algorithm. See OnsetDetection for more information.| Please note that due to a dependence on the Onsets algorithm, this algorithm| is only valid for audio signals with a sampling rate of 44100Hz.| This algorithm throws an exception if the input signal is empty.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Onsets = class Algo(Algorithm)| Onsets||| Inputs:|| [matrix_real] detections - matrix containing onset detection functions--rows represent the values of different detection functions and columns represent different frames of audio (i.e. detections[i][j] represents the value of the ith detection function for the jth frame of audio)| [vector_real] weights - the weighting coefficicients for each detection function, must be the same as the first dimension of "detections"||| Outputs:|| [vector_real] onsets - the onset positions [s]||| Parameters:|| alpha:| real ∈ [0,1] (default = 0.10000000149)| the proportion of the mean included to reject smaller peaks--filters very| short onsets|| delay:| integer ∈ (0,inf) (default = 5)| the number of frames used to compute the threshold--size of short-onset| filter|| frameRate:| real ∈ (0,inf) (default = 86.1328125)| frames per second|| silenceThreshold:| real ∈ [0,1] (default = 0.019999999553)| the threshold for silence||| Description:|| This algorithm computes onset positions given various onset detection| functions.|| The main operations are:| - normalizing detection functions,| - summing detection functions into a global detection function,| - smoothing the global detection function,| - thresholding the global detection function for silence,| - finding the possible onsets using an adaptative threshold,| - cleaning operations on the vector of possible onsets,| - onsets time conversion.|| Note:| - This algorithm has been optimized for a frameRate of 44100.0/512.0.| - At least one Detection function must be supplied at input.| - The number of weights must match the number of detection functions.|| As mentioned above, the "frameRate" parameter expects a value of 44100/512| (the default), but will work with other values, although the quality of the| results is not guaranteed then. An exception is also thrown if the input| "detections" matrix is empty. Finally, an exception is thrown if the size of| the "weights" input does not equal the first dimension of the "detections"| matrix.|| References:| [1] P. Brossier, J. P. Bello, and M. D. Plumbley, "Fast labelling of notes| in music signals,” in International Symposium on Music Information| Retrieval (ISMIR’04), 2004, pp. 331–336.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).OverlapAdd = class Algo(Algorithm)| OverlapAdd||| Inputs:|| [vector_real] signal - the windowed input audio frame||| Outputs:|| [vector_real] signal - the output overlap-add audio signal frame||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing the overlap-add process|| gain:| real ∈ (0.,inf) (default = 1)| the normalization gain that scales the output signal. Useful for IFFT| output|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the overlap-add function is computed||| Description:|| This algorithm returns the output of an overlap-add process for a sequence of| frames of an audio signal. It considers that the input audio frames are| windowed audio signals. Giving the size of the frame and the hop size,| overlapping and adding consecutive frames will produce a continuous signal. A| normalization gain can be passed as a parameter.|| Empty input signals will raise an exception.|| References:| [1] Overlap–add method - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Overlap-add_method|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm r...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PCA = class Algo(Algorithm)| PCA||| Inputs:|| [pool] poolIn - the pool where to get the spectral contrast feature vectors||| Outputs:|| [pool] poolOut - the pool where to store the transformed feature vectors||| Parameters:|| dimensions:| integer ∈ [0, inf) (default = 0)| number of dimension to reduce the input to|| namespaceIn:| string (default = "spectral contrast")| will look for this namespace in poolIn|| namespaceOut:| string (default = "spectral contrast pca")| will save to this namespace in poolOut||| Description:|| This algorithm applies Principal Component Analysis based on the covariance| matrix of the signal.|| References:| [1] Principal component analysis - Wikipedia, the free enciclopedia| http://en.wikipedia.org/wiki/Principal_component_analysis|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Transformations', 'description': 'This algo...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Panning = class Algo(Algorithm)| Panning||| Inputs:|| [vector_real] spectrumLeft - left channel's spectrum| [vector_real] spectrumRight - right channel's spectrum||| Outputs:|| [matrix_real] panningCoeffs - parameters that define the panning curve at each frame||| Parameters:|| averageFrames:| integer ∈ [0,inf) (default = 43)| number of frames to take into account for averaging|| numBands:| integer ∈ [1,inf) (default = 1)| number of mel bands|| numCoeffs:| integer ∈ (0,inf) (default = 20)| number of coefficients used to define the panning curve at each frame|| panningBins:| integer ∈ (1,inf) (default = 512)| size of panorama histogram (in bins)|| sampleRate:| real ∈ (0,inf) (default = 44100)| audio sampling rate [Hz]|| warpedPanorama:| bool ∈ {false,true} (default = true)| if true, warped panorama is applied, having more resolution in the center| area||| Description:|| This algorithm characterizes panorama distribution by comparing spectra from| the left and right channels. The panning coefficients are extracted by:|| - determining the spatial location of frequency bins given left and right| channel spectra;|| - computing panorama histogram weighted by the energy of frequency bins,| averaging it across frames and normalizing;|| - converting the normalized histogram into panning coefficients (IFFT of the| log-histogram).|| The resulting coefficients will show peaks on the initial bins for left| panned audio, and right panning will appear as peaks in the upper bins.|| Since panning can vary very rapidly from one frame to the next, the| coefficients can be averaged over a time window of several frames by| specifying "averageFrames" parameter. If a single vector of panning| coefficients for the whole audio input is required, "averageFrames" should| correspond to the length of audio input. In standard mode, sequential runs of| compute() method on each frame are required for averaging across frames.|| Application: music classification, in particular genre classification [2].|| Note: At present time, the original algorithm has not been tested in| multi-band mode. That is, numBands must remain 1.| References:| [1] E. Gómez, P. Herrera, P. Cano, J. Janer, J. Serrà, J. Bonada,| S. El-Hajj, T. Aussenac, and G. Holmberg, "Music similarity systems and| methods using descriptors,” U.S. Patent WO 2009/0012022009.|| [2] Guaus, E. (2009). Audio content processing for automatic music genre| classification: descriptors, databases, and classifiers. PhD Thesis.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PeakDetection = class Algo(Algorithm)| PeakDetection||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] positions - the positions of the peaks| [vector_real] amplitudes - the amplitudes of the peaks||| Parameters:|| interpolate:| bool ∈ {true,false} (default = true)| boolean flag to enable interpolation|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxPosition:| real ∈ (0,inf) (default = 1)| the maximum value of the range to evaluate|| minPeakDistance:| real ∈ [0,inf) (default = 0)| minimum distance between consecutive peaks (0 to bypass this feature)|| minPosition:| real ∈ [0,inf) (default = 0)| the minimum value of the range to evaluate|| orderBy:| string ∈ {position,amplitude} (default = "position")| the ordering type of the output peaks (ascending by position or descending| by value)|| range:| real ∈ (0,inf) (default = 1)| the input range|| threshold:| real ∈ (-inf,inf) (default = -1000000)| peaks below this given threshold are not output||| Description:|| This algorithm detects local maxima (peaks) in an array. The algorithm finds| positive slopes and detects a peak when the slope changes sign and the peak| is above the threshold.| It optionally interpolates using parabolic curve fitting.| When two consecutive peaks are closer than the `minPeakDistance` parameter,| the smallest one is discarded. A value of 0 bypasses this feature.|| Exceptions are thrown if parameter "minPosition" is greater than parameter| "maxPosition", also if the size of the input array is less than 2 elements.|| References:| [1] Peak Detection,| http://ccrma.stanford.edu/~jos/parshl/Peak_Detection_Steps_3.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm d...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PercivalBpmEstimator = class Algo(Algorithm)| PercivalBpmEstimator||| Inputs:|| [vector_real] signal - input signal||| Outputs:|| [real] bpm - the tempo estimation [bpm]||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 1024)| frame size for the analysis of the input signal|| frameSizeOSS:| integer ∈ (0,inf) (default = 2048)| frame size for the analysis of the Onset Strength Signal|| hopSize:| integer ∈ (0,inf) (default = 128)| hop size for the analysis of the input signal|| hopSizeOSS:| integer ∈ (0,inf) (default = 128)| hop size for the analysis of the Onset Strength Signal|| maxBPM:| integer ∈ (0,inf) (default = 210)| maximum BPM to detect|| minBPM:| integer ∈ (0,inf) (default = 50)| minimum BPM to detect|| sampleRate:| integer ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm estimates the tempo in beats per minute (BPM) from an input| signal as described in [1].|| References:| [1] Percival, G., & Tzanetakis, G. (2014). Streamlined tempo estimation| based on autocorrelation and cross-correlation with pulses.| IEEE/ACM Transactions on Audio, Speech, and Language Processing, 22(12),| 1765–1776.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PercivalEnhanceHarmonics = class Algo(Algorithm)| PercivalEnhanceHarmonics||| Inputs:|| [vector_real] array - the input signal||| Outputs:|| [vector_real] array - the input signal with enhanced harmonics||| Description:|| This algorithm implements the 'Enhance Harmonics' step as described in| [1].Given an input autocorrelation signal, two time-stretched versions of it| (by factors of 2 and 4) are added to the original.In this way, peaks with an| harmonic relation are boosted.| For more details check the referenced paper.|| References:| [1] Percival, G., & Tzanetakis, G. (2014). Streamlined tempo estimation| based on autocorrelation and cross-correlation with pulses.| IEEE/ACM Transactions on Audio, Speech, and Language Processing, 22(12),| 1765–1776.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': "This algorithm imp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PercivalEvaluatePulseTrains = class Algo(Algorithm)| PercivalEvaluatePulseTrains||| Inputs:|| [vector_real] oss - onset strength signal (or other novelty curve)| [vector_real] positions - peak positions of BPM candidates||| Outputs:|| [real] lag - best tempo lag estimate||| Description:|| This algorithm implements the 'Evaluate Pulse Trains' step as described in| [1].Given an input onset strength signal (OSS) and a number of candidate| tempo lag positions, the OSS is correlated with ideal expected pulse trains| (for each candidate tempo lag) shifted in time by different amounts. The| candidate tempo lag which generates the pulse train that better correlates| with the OSS is returned as the preferred tempo candidate.| For more details check the referenced paper.|| References:| [1] Percival, G., & Tzanetakis, G. (2014). Streamlined tempo estimation| based on autocorrelation and cross-correlation with pulses.| IEEE/ACM Transactions on Audio, Speech, and Language Processing, 22(12),| 1765–1776.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': "This algorithm imp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchContourSegmentation = class Algo(Algorithm)| PitchContourSegmentation||| Inputs:|| [vector_real] pitch - estimated pitch contour [Hz]| [vector_real] signal - input audio signal||| Outputs:|| [vector_real] onset - note onset times [s]| [vector_real] duration - note durations [s]| [vector_real] MIDIpitch - quantized MIDI pitch value||| Parameters:|| hopSize:| integer ∈ (0,inf) (default = 128)| hop size of the extracted pitch|| minDuration:| real ∈ (0,inf) (default = 0.10000000149)| minimum note duration [s]|| pitchDistanceThreshold:| integer ∈ (0,inf) (default = 60)| pitch threshold for note segmentation [cents]|| rmsThreshold:| integer ∈ (-inf,0) (default = -2)| zscore threshold for note segmentation|| sampleRate:| integer ∈ (0,inf) (default = 44100)| sample rate of the audio signal|| tuningFrequency:| integer ∈ (0,22000) (default = 440)| tuning reference frequency [Hz]||| Description:|| This algorithm converts a pitch sequence estimated from an audio signal into| a set of discrete note events. Each note is defined by its onset time,| duration and MIDI pitch value, quantized to the equal tempered scale.|| Note segmentation is performed based on pitch contour characteristics (island| building) and signal RMS. Notes below an adjustable minimum duration are| rejected.|| References:| [1] R. J. McNab et al., "Signal processing for melody transcription," in| Proc.| Proc. 19th Australasian Computer Science Conf., 1996|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm conv...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchContours = class Algo(Algorithm)| PitchContours||| Inputs:|| [vector_vector_real] peakBins - frame-wise array of cent bins corresponding to pitch salience function peaks| [vector_vector_real] peakSaliences - frame-wise array of values of salience function peaks||| Outputs:|| [vector_vector_real] contoursBins - array of frame-wise vectors of cent bin values representing each contour| [vector_vector_real] contoursSaliences - array of frame-wise vectors of pitch saliences representing each contour| [vector_real] contoursStartTimes - array of start times of each contour [s]| [real] duration - time duration of the input signal [s]||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| minDuration:| real ∈ (0,inf) (default = 100)| the minimum allowed contour duration [ms]|| peakDistributionThreshold:| real ∈ [0,2] (default = 0.899999976158)| allowed deviation below the peak salience mean over all frames (fraction of| the standard deviation)|| peakFrameThreshold:| real ∈ [0,1] (default = 0.899999976158)| per-frame salience threshold factor (fraction of the highest peak salience| in a frame)|| pitchContinuity:| real ∈ [0,inf) (default = 27.5625)| pitch continuity cue (maximum allowed pitch change durig 1 ms time period)| [cents]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| timeContinuity:| real ∈ (0,inf) (default = 100)| time continuity cue (the maximum allowed gap duration for a pitch contour)| [ms]||| Description:|| This algorithm tracks a set of predominant pitch contours of an audio signal.| This algorithm is intended to receive its "frequencies" and "magnitudes"| inputs from the PitchSalienceFunctionPeaks algorithm outputs aggregated over| all frames in the sequence. The output is a vector of estimated melody pitch| values.|| When input vectors differ in size, an exception is thrown. Input vectors must| not contain negative salience values otherwise an exception is thrown.| Avoiding erroneous peak duplicates (peaks of the same cent bin) is up to the| user's own control and is highly recommended, but no exception will be| thrown.|| Recommended processing chain: (see [1]): EqualLoudness -> frame slicing with| sample rate = 44100, frame size = 2048, hop size = 128 -> Windowing with| Hann, x4 zero padding -> Spectrum -> SpectralPeaks -> PitchSalienceFunction| (10 cents bin resolution) -> PitchSalienceFunctionPeaks.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm trac...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchContoursMelody = class Algo(Algorithm)| PitchContoursMelody||| Inputs:|| [vector_vector_real] contoursBins - array of frame-wise vectors of cent bin values representing each contour| [vector_vector_real] contoursSaliences - array of frame-wise vectors of pitch saliences representing each contour| [vector_real] contoursStartTimes - array of the start times of each contour [s]| [real] duration - time duration of the input signal [s]||| Outputs:|| [vector_real] pitch - vector of estimated pitch values (i.e., melody) [Hz]| [vector_real] pitchConfidence - confidence with which the pitch was detected||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of interations for the octave errors / pitch outlier filtering| process|| guessUnvoiced:| bool ∈ {false,true} (default = false)| Estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minFrequency:| real ∈ [0,inf) (default = 80)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal (Hz)|| voiceVibrato:| bool ∈ {true,false} (default = false)| detect voice vibrato|| voicingTolerance:| real ∈ [-1.0,1.4] (default = 0.20000000298)| allowed deviation below the average contour mean salience of all contours| (fraction of the standard deviation)||| Description:|| This algorithm converts a set of pitch contours into a sequence of| predominant f0 values in Hz by taking the value of the most predominant| contour in each frame.| This algorithm is intended to receive its "contoursBins",| "contoursSaliences", and "contoursStartTimes" inputs from the PitchContours| algorithm. The "duration" input corresponds to the time duration of the input| signal. The output is a vector of estimated pitch values and a vector of| confidence values.|| Note that "pitchConfidence" can be negative in the case of| "guessUnvoiced"=True: the absolute values represent the confidence, negative| values correspond to segments for which non-salient contours where selected,| zero values correspond to non-voiced segments.|| When input vectors differ in size, or "numberFrames" is negative, an| exception is thrown. Input vectors must not contain negative start indices| nor negative bin and salience values otherwise an exception is thrown.|| Recommended processing chain: (see [1]): EqualLoudness -> frame slicing with| sample rate = 44100, frame size = 2048, hop size = 128 -> Windowing with| Hann, x4 zero padding -> Spectrum -> SpectralPeaks -> PitchSalienceFunction| -> PitchSalienceFunctionPeaks -> PitchContours.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm conv...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchContoursMonoMelody = class Algo(Algorithm)| PitchContoursMonoMelody||| Inputs:|| [vector_vector_real] contoursBins - array of frame-wise vectors of cent bin values representing each contour| [vector_vector_real] contoursSaliences - array of frame-wise vectors of pitch saliences representing each contour| [vector_real] contoursStartTimes - array of the start times of each contour [s]| [real] duration - time duration of the input signal [s]||| Outputs:|| [vector_real] pitch - vector of estimated pitch values (i.e., melody) [Hz]| [vector_real] pitchConfidence - confidence with which the pitch was detected||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of interations for the octave errors / pitch outlier filtering| process|| guessUnvoiced:| bool ∈ {false,true} (default = false)| Estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minFrequency:| real ∈ [0,inf) (default = 80)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal (Hz)||| Description:|| This algorithm converts a set of pitch contours into a sequence of f0 values| in Hz by taking the value of the most salient contour in each frame.| In contrast to pitchContoursMelody, it assumes a single source.| This algorithm is intended to receive its "contoursBins",| "contoursSaliences", and "contoursStartTimes" inputs from the PitchContours| algorithm. The "duration" input corresponds to the time duration of the input| signal. The output is a vector of estimated pitch values and a vector of| confidence values.|| Note that "pitchConfidence" can be negative in the case of| "guessUnvoiced"=True: the absolute values represent the confidence, negative| values correspond to segments for which non-salient contours where selected,| zero values correspond to non-voiced segments.|| When input vectors differ in size, or "numberFrames" is negative, an| exception is thrown. Input vectors must not contain negative start indices| nor negative bin and salience values otherwise an exception is thrown.|| Recommended processing chain: (see [1]): EqualLoudness -> frame slicing with| sample rate = 44100, frame size = 2048, hop size = 128 -> Windowing with| Hann, x4 zero padding -> Spectrum -> SpectralPeaks -> PitchSalienceFunction| -> PitchSalienceFunctionPeaks -> PitchContours.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm conv...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchContoursMultiMelody = class Algo(Algorithm)| PitchContoursMultiMelody||| Inputs:|| [vector_vector_real] contoursBins - array of frame-wise vectors of cent bin values representing each contour| [vector_vector_real] contoursSaliences - array of frame-wise vectors of pitch saliences representing each contour| [vector_real] contoursStartTimes - array of the start times of each contour [s]| [real] duration - time duration of the input signal [s]||| Outputs:|| [vector_vector_real] pitch - vector of estimated pitch values (i.e., melody) [Hz]||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of interations for the octave errors / pitch outlier filtering| process|| guessUnvoiced:| bool ∈ {false,true} (default = false)| Estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minFrequency:| real ∈ [0,inf) (default = 80)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal (Hz)||| Description:|| This algorithm post-processes a set of pitch contours into a sequence of| mutliple f0 values in Hz.| This algorithm is intended to receive its "contoursBins",| "contoursSaliences", and "contoursStartTimes" inputs from the PitchContours| algorithm. The "duration" input corresponds to the time duration of the input| signal. The output is a vector of estimated pitch values|| When input vectors differ in size, or "numberFrames" is negative, an| exception is thrown. Input vectors must not contain negative start indices| nor negative bin and salience values otherwise an exception is thrown.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm post...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchFilter = class Algo(Algorithm)| PitchFilter||| Inputs:|| [vector_real] pitch - vector of pitch values for the input frames [Hz]| [vector_real] pitchConfidence - vector of pitch confidence values for the input frames||| Outputs:|| [vector_real] pitchFiltered - vector of corrected pitch values [Hz]||| Parameters:|| confidenceThreshold:| integer ∈ [0,inf) (default = 36)| ratio between the average confidence of the most confident chunk and the| minimum allowed average confidence of a chunk|| minChunkSize:| integer ∈ [0,inf) (default = 30)| minumum number of frames in non-zero pitch chunks|| useAbsolutePitchConfidence:| bool ∈ {true,false} (default = false)| treat negative pitch confidence values as positive (use with melodia| guessUnvoiced=True)||| Description:|| This algorithm corrects the fundamental frequency estimations for a sequence| of frames given pitch values together with their confidence values. In| particular, it removes non-confident parts and spurious jumps in pitch and| applies octave corrections.|| They can be computed with the PitchYinFFT, PitchYin, or| PredominantPitchMelodia algorithms.| If you use PredominantPitchMelodia with guessUnvoiced=True, set| useAbsolutePitchConfidence=True.|| The algorithm can be used for any type of monophonic and heterophonic music.|| The original algorithm [1] was proposed to be used for Makam music and| employs signal"energy" of frames instead of pitch confidence.|| References:| [1] B. Bozkurt, "An Automatic Pitch Analysis Method for Turkish Maqam| Music," Journal of New Music Research. 37(1), 1-13.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm corr...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchMelodia = class Algo(Algorithm)| PitchMelodia||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] pitch - the estimated pitch values [Hz]| [vector_real] pitchConfidence - confidence with which the pitch was detected||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of iterations for the octave errors / pitch outlier filtering| process|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing pitch saliecnce|| guessUnvoiced:| bool ∈ {false,true} (default = false)| estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| harmonicWeight:| real ∈ (0,1) (default = 0.800000011921)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter for the salience function (=0 for maximum| compression, =1 for no compression)|| magnitudeThreshold:| integer ∈ [0,inf) (default = 40)| spectral peak magnitude threshold (maximum allowed difference from the| highest peak in dBs)|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minDuration:| integer ∈ (0,inf) (default = 100)| the minimum allowed contour duration [ms]|| minFrequency:| real ∈ [0,inf) (default = 40)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| numberHarmonics:| integer ∈ [1,inf) (default = 20)| number of considered harmonics|| peakDistributionThreshold:| real ∈ [0,2] (default = 0.899999976158)| allowed deviation below the peak salience mean over all frames (fraction of| the standard deviation)|| peakFrameThreshold:| real ∈ [0,1] (default = 0.899999976158)| per-frame salience threshold factor (fraction of the highest peak salience| in a frame)|| pitchContinuity:| real ∈ [0,inf) (default = 27.5625)| pitch continuity cue (maximum allowed pitch change during 1 ms time period)| [cents]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| timeContinuity:| integer ∈ (0,inf) (default = 100)| time continuity cue (the maximum allowed gap duration for a pitch contour)| [ms]||| Description:|| This algorithm estimates the fundamental frequency corresponding to the| melody of a monophonic music signal based on the MELODIA algorithm. While the| algorithm is originally designed to extract the predominant melody from| polyphonic music [1], this implementation is adapted for monophonic signals.| The approach is based on the creation and characterization of pitch contours,| time continuous sequences of pitch candidates grouped using auditory| streaming cues. To this end, PitchSalienceFunction,| PitchSalienceFunctionPeaks, PitchContours, and PitchContoursMonoMelody| algorithms are employed. It is strongly advised to use the default parameter| values which are optimized according to [1] (where further details are| provided) except for minFrequency and maxFrequency, which will depend on your| application.|| The output is a vector of estimated melody pitch values and a vector of| confidence values.|| It is recommended to apply EqualLoudness on the input signal (see [1]) as a| pre-processing stage before running this algorithm.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| [2] http://mtg.upf.edu/technologies/melodia|| [3] http://www.justinsalamon.com/melody-extraction|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchSalience = class Algo(Algorithm)| PitchSalience||| Inputs:|| [vector_real] spectrum - the input audio spectrum||| Outputs:|| [real] pitchSalience - the pitch salience (normalized from 0 to 1)||| Parameters:|| highBoundary:| real ∈ (0,inf) (default = 5000)| until which frequency we are looking for the minimum (must be smaller than| half sampleRate) [Hz]|| lowBoundary:| real ∈ (0,inf) (default = 100)| from which frequency we are looking for the maximum (must not be larger| than highBoundary) [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the pitch salience of a spectrum. The pitch salience| is given by the ratio of the highest auto correlation value of the spectrum| to the non-shifted auto correlation value. Pitch salience was designed as| quick measure of tone sensation. Unpitched sounds (non-musical sound effects)| and pure tones have an average pitch salience value close to 0 whereas sounds| containing several harmonics in the spectrum tend to have a higher value.|| Note that this algorithm may give better results when used with low sampling| rates (i.e. 8000) as the information in the bands musically meaningful will| have more relevance.|| This algorithm uses AutoCorrelation on the input "spectrum" and thus inherits| its input requirements and exceptions. An exception is thrown at| configuration time if "lowBoundary" is larger than "highBoundary" and/or if| "highBoundary" is not smaller than half "sampleRate". At computation time, an| exception is thrown if the input spectrum is empty. Also note that feeding| silence to this algorithm will return zero.|| Application: characterizing percussive sounds.|| References:| [1] J. Ricard "Towards computational morphological description of sound.| DEA pre-thesis research work, Universitat Pompeu Fabra, Barcelona, 2004.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchSalienceFunction = class Algo(Algorithm)| PitchSalienceFunction||| Inputs:|| [vector_real] frequencies - the frequencies of the spectral peaks [Hz]| [vector_real] magnitudes - the magnitudes of the spectral peaks||| Outputs:|| [vector_real] salienceFunction - array of the quantized pitch salience values||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| harmonicWeight:| real ∈ (0,1) (default = 0.800000011921)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter (=0 for maximum compression, =1 for no| compression)|| magnitudeThreshold:| real ∈ [0,inf) (default = 40)| peak magnitude threshold (maximum allowed difference from the highest peak| in dBs)|| numberHarmonics:| integer ∈ [1,inf) (default = 20)| number of considered harmonics|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin||| Description:|| This algorithm computes the pitch salience function of a signal frame given| its spectral peaks. The salience function covers a pitch range of nearly five| octaves (i.e., 6000 cents), starting from the "referenceFrequency", and is| quantized into cent bins according to the specified "binResolution". The| salience of a given frequency is computed as the sum of the weighted energies| found at integer multiples (harmonics) of that frequency.|| This algorithm is intended to receive its "frequencies" and "magnitudes"| inputs from the SpectralPeaks algorithm. The output is a vector of salience| values computed for the cent bins. The 0th bin corresponds to the specified| "referenceFrequency".|| When input vectors differ in size or are empty, an exception is thrown. Input| vectors must contain positive frequencies and not contain negative magnitudes| otherwise an exception is thrown. It is highly recommended to avoid erroneous| peak duplicates (peaks of the same frequency occuring more than ones), but it| is up to the user's own control and no exception will be thrown.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchSalienceFunctionPeaks = class Algo(Algorithm)| PitchSalienceFunctionPeaks||| Inputs:|| [vector_real] salienceFunction - the array of salience function values corresponding to cent frequency bins||| Outputs:|| [vector_real] salienceBins - the cent bins corresponding to salience function peaks| [vector_real] salienceValues - the values of salience function peaks||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| maxFrequency:| real ∈ [0,inf) (default = 1760)| the maximum frequency to evaluate (ignore peaks above) [Hz]|| minFrequency:| real ∈ [0,inf) (default = 55)| the minimum frequency to evaluate (ignore peaks below) [Hz]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin||| Description:|| This algorithm computes the peaks of a given pitch salience function.|| This algorithm is intended to receive its "salienceFunction" input from the| PitchSalienceFunction algorithm. The peaks are detected using PeakDetection| algorithm. The outputs are two arrays of bin numbers and salience values| corresponding to the peaks.|| References:| [1] Salamon, J., & Gómez E. (2012). Melody Extraction from Polyphonic| Music Signals using Pitch Contour Characteristics.| IEEE Transactions on Audio, Speech and Language Processing. 20(6),| 1759-1770.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchYin = class Algo(Algorithm)| PitchYin||| Inputs:|| [vector_real] signal - the input signal frame||| Outputs:|| [real] pitch - detected pitch [Hz]| [real] pitchConfidence - confidence with which the pitch was detected [0,1]||| Parameters:|| frameSize:| integer ∈ [2,inf) (default = 2048)| number of samples in the input frame (this is an optional parameter to| optimize memory allocation)|| interpolate:| bool ∈ {true,false} (default = true)| enable interpolation|| maxFrequency:| real ∈ (0,inf) (default = 22050)| the maximum allowed frequency [Hz]|| minFrequency:| real ∈ (0,inf) (default = 20)| the minimum allowed frequency [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| sampling rate of the input audio [Hz]|| tolerance:| real ∈ [0,1] (default = 0.15000000596)| tolerance for peak detection||| Description:|| This algorithm estimates the fundamental frequency given the frame of a| monophonic music signal. It is an implementation of the Yin algorithm [1] for| computations in the time domain.|| An exception is thrown if an empty signal is provided.|| Please note that if "pitchConfidence" is zero, "pitch" is undefined and| should not be used for other algorithms.| Also note that a null "pitch" is never ouput by the algorithm and that| "pitchConfidence" must always be checked out.|| References:| [1] De Cheveigné, A., & Kawahara, H. "YIN, a fundamental frequency| estimator| for speech and music. The Journal of the Acoustical Society of America,| 111(4), 1917-1930, 2002.|| [2] Pitch detection algorithm - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Pitch_detection_algorithm|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchYinFFT = class Algo(Algorithm)| PitchYinFFT||| Inputs:|| [vector_real] spectrum - the input spectrum (preferably created with a hann window)||| Outputs:|| [real] pitch - detected pitch [Hz]| [real] pitchConfidence - confidence with which the pitch was detected [0,1]||| Parameters:|| frameSize:| integer ∈ [2,inf) (default = 2048)| number of samples in the input spectrum|| interpolate:| bool ∈ {true,false} (default = true)| boolean flag to enable interpolation|| maxFrequency:| real ∈ (0,inf) (default = 22050)| the maximum allowed frequency [Hz]|| minFrequency:| real ∈ (0,inf) (default = 20)| the minimum allowed frequency [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| sampling rate of the input spectrum [Hz]|| tolerance:| real ∈ [0,1] (default = 1)| tolerance for peak detection||| Description:|| This algorithm estimates the fundamental frequency given the spectrum of a| monophonic music signal. It is an implementation of YinFFT algorithm [1],| which is an optimized version of Yin algorithm for computation in the| frequency domain. It is recommended to window the input spectrum with a Hann| window. The raw spectrum can be computed with the Spectrum algorithm.|| An exception is thrown if an empty spectrum is provided.|| Please note that if "pitchConfidence" is zero, "pitch" is undefined and| should not be used for other algorithms.| Also note that a null "pitch" is never ouput by the algorithm and that| "pitchConfidence" must always be checked out.|| References:| [1] P. M. Brossier, "Automatic Annotation of Musical Audio for Interactive| Applications,” QMUL, London, UK, 2007.|| [2] Pitch detection algorithm - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Pitch_detection_algorithm|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchYinProbabilistic = class Algo(Algorithm)| PitchYinProbabilistic||| Inputs:|| [vector_real] signal - the input mono audio signal||| Outputs:|| [vector_real] pitch - the output pitch estimations| [vector_real] voicedProbabilities - the voiced probabilities||| Parameters:|| frameSize:| integer ∈ (0, inf) (default = 2048)| the frame size of FFT|| hopSize:| integer ∈ [1,inf) (default = 256)| the hop size with which the pitch is computed|| lowRMSThreshold:| real ∈ (0,1] (default = 0.10000000149)| the low RMS amplitude threshold|| outputUnvoiced:| string ∈ {zero,abs,negative} (default = "negative")| whether output unvoiced frame, zero: output non-voiced pitch as 0.; abs:| output non-voiced pitch as absolute values; negative: output non-voiced| pitch as negative values|| preciseTime:| bool ∈ {true,false} (default = false)| use non-standard precise YIN timing (slow).|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the pitch track of a mono audio signal using| probabilistic Yin algorithm.|| - The input mono audio signal is preprocessed with a FrameCutter to segment| into frameSize chunks with a overlap hopSize.| - The pitch frequencies, probabilities and RMS values of the chunks are then| calculated by PitchYinProbabilities algorithm. The results of all chunks are| aggregated into a Essentia pool.| - The pitch frequencies and probabilities are finally sent to| PitchYinProbabilitiesHMM algorithm to get a smoothed pitch track and a voiced| probability.|| References:| [1] M. Mauch and S. Dixon, "pYIN: A Fundamental Frequency Estimator| Using Probabilistic Threshold Distributions," in Proceedings of the| IEEE International Conference on Acoustics, Speech, and Signal Processing| (ICASSP 2014)Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchYinProbabilities = class Algo(Algorithm)| PitchYinProbabilities||| Inputs:|| [vector_real] signal - the input signal frame||| Outputs:|| [vector_real] pitch - the output pitch candidate frequencies in cents| [vector_real] probabilities - the output pitch candidate probabilities| [real] RMS - the output RMS value||| Parameters:|| frameSize:| integer ∈ [2,inf) (default = 2048)| number of samples in the input frame|| lowAmp:| real ∈ (0,1] (default = 0.10000000149)| the low RMS amplitude threshold|| preciseTime:| bool ∈ {true,false} (default = false)| use non-standard precise YIN timing (slow).|| sampleRate:| real ∈ (0,inf) (default = 44100)| sampling rate of the input audio [Hz]||| Description:|| This algorithm estimates the fundamental frequencies, their probabilities| given the frame of a monophonic music signal. It is a part of the| implementation of the probabilistic Yin algorithm [1].|| An exception is thrown if an empty signal is provided.|| References:| [1] M. Mauch and S. Dixon, "pYIN: A Fundamental Frequency Estimator| Using Probabilistic Threshold Distributions," in Proceedings of the| IEEE International Conference on Acoustics, Speech, and Signal Processing| (ICASSP 2014)Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PitchYinProbabilitiesHMM = class Algo(Algorithm)| PitchYinProbabilitiesHMM||| Inputs:|| [vector_vector_real] pitchCandidates - the pitch candidates| [vector_vector_real] probabilities - the pitch probabilities||| Outputs:|| [vector_real] pitch - pitch frequencies in Hz||| Parameters:|| minFrequency:| real ∈ (0,inf) (default = 61.7350006104)| minimum detected frequency|| numberBinsPerSemitone:| integer ∈ (1,inf) (default = 5)| number of bins per semitone|| selfTransition:| real ∈ (0,1) (default = 0.990000009537)| the self transition probabilities|| yinTrust:| real ∈ (0, 1) (default = 0.5)| the yin trust parameter||| Description:|| This algorithm estimates the smoothed fundamental frequency given the pitch| candidates and probabilities using hidden Markov models. It is a part of the| implementation of the probabilistic Yin algorithm [1].|| An exception is thrown if an empty signal is provided.|| References:| [1] M. Mauch and S. Dixon, "pYIN: A Fundamental Frequency Estimator| Using Probabilistic Threshold Distributions," in Proceedings of the| IEEE International Conference on Acoustics, Speech, and Signal Processing| (ICASSP 2014)Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PolarToCartesian = class Algo(Algorithm)| PolarToCartesian||| Inputs:|| [vector_real] magnitude - the magnitude vector| [vector_real] phase - the phase vector||| Outputs:|| [vector_complex] complex - the resulting complex vector||| Description:|| This algorithm converts an array of complex numbers from polar to cartesian| form. It uses the Euler formula:| z = x + i*y = |z|(cos(α) + i sin(α))| where x = Real part, y = Imaginary part,| and |z| = modulus = magnitude, α = phase|| An exception is thrown if the size of the magnitude vector does not match the| size of the phase vector.|| References:| [1] Polar coordinate system - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Polar_coordinates|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Math', 'description': 'This algorithm conve...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PoolAggregator = class Algo(Algorithm)| PoolAggregator||| Inputs:|| [pool] input - the input pool||| Outputs:|| [pool] output - a pool containing the aggregate values of the input pool||| Parameters:|| defaultStats:| vector_string (default = ["mean", "stdev", "min", "max", "median"])| the default statistics to be computed for each descriptor in the input pool|| exceptions:| map_vector_string (default = {})| a mapping between descriptor names (no duplicates) and the types of| statistics to be computed for those descriptors (e.g. { lowlevel.bpm :| [min, max], lowlevel.gain : [var, min, dmean] })||| Description:|| This algorithm performs statistical aggregation on a Pool and places the| results of the aggregation into a new Pool. Supported statistical units are:| - 'min' (minimum),| - 'max' (maximum),| - 'median',| - 'mean',| - 'var' (variance),| - 'stdev' (standard deviation),| - 'skew' (skewness),| - 'kurt' (kurtosis),| - 'dmean' (mean of the derivative),| - 'dvar' (variance of the derivative),| - 'dmean2' (mean of the second derivative),| - 'dvar2' (variance of the second derivative),| - 'cov' (covariance), and| - 'icov' (inverse covariance).| - 'value' (copy of descriptor, but the value is placed under the name| '<descriptor name>.value')| - 'copy' (verbatim copy of descriptor, no aggregation; exclusive: cannot be| performed with any other statistical units).| - 'last' (last value of descriptor placed under the name '<descriptor| name>'; exclusive: cannot be performed with any other statistical units|| These statistics can be computed for single-dimensional vectors (vectors of| Reals) and two-dimensional vectors (vectors of vectors of Reals) in the Pool.| Statistics for two-dimensional vectors are computed by aggregating each| column placing the result into a vector of the same size as the size of each| vector in the input Pool under the given descriptor (which implies their| equal size).|| In the case of 'cov' and 'icov', two-dimensional vectors are required, and| each statistic returns a square matrix with the dimensions equal to the| length of the vectors under the given descriptor. Computing 'icov' requires| the corresponding covariance matrix to be invertible.|| Note that only the absolute values of the first and second derivatives are| considered when computing their mean ('dmean' and 'dmean2') and variance| ('dvar' and 'dvar2'). This is to avoid a trivial solution for the mean.|| For vectors, if the input pool value consists of only one vector, its| aggregation will be skipped, and the vector itself will be added to the| output.|| The 'value' and 'copy' are auxiliary aggregation methods that can be used to| copy values in the input Pool to the output Pool without aggregation. In the| case of 'last', the last value in the input vector of Reals (or input vector| of vectors of Reals) will be taken and saved as a single Real (or single| vector of Reals) in the output Pool.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PowerMean = class Algo(Algorithm)| PowerMean||| Inputs:|| [vector_real] array - the input array (must contain only positive real numbers)||| Outputs:|| [real] powerMean - the power mean of the input array||| Parameters:|| power:| real ∈ (-inf,inf) (default = 1)| the power to which to elevate each element before taking the mean||| Description:|| This algorithm computes the power mean of an array. It accepts one parameter,| p, which is the power (or order or degree) of the Power Mean. Note that if| p=-1, the Power Mean is equal to the Harmonic Mean, if p=0, the Power Mean is| equal to the Geometric Mean, if p=1, the Power Mean is equal to the| Arithmetic Mean, if p=2, the Power Mean is equal to the Root Mean Square.|| Exceptions are thrown if input array either is empty or it contains non| positive numbers.|| References:| [1] Power Mean -- from Wolfram MathWorld,| http://mathworld.wolfram.com/PowerMean.html| [2] Generalized mean - Wikipedia, the free encyclopedia,| https://en.wikipedia.org/wiki/Generalized_mean|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PowerSpectrum = class Algo(Algorithm)| PowerSpectrum||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] powerSpectrum - power spectrum of the input signal||| Parameters:|| size:| integer ∈ [1,inf) (default = 2048)| the expected size of the input frame (this is purely optional and only| targeted at optimizing the creation time of the FFT object)||| Description:|| This algorithm computes the power spectrum of an array of Reals. The| resulting power spectrum has a size which is half the size of the input array| plus one. Bins contain squared magnitude values.|| References:| [1] Power Spectrum - from Wolfram MathWorld,| http://mathworld.wolfram.com/PowerSpectrum.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).PredominantPitchMelodia = class Algo(Algorithm)| PredominantPitchMelodia||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] pitch - the estimated pitch values [Hz]| [vector_real] pitchConfidence - confidence with which the pitch was detected||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| filterIterations:| integer ∈ [1,inf) (default = 3)| number of iterations for the octave errors / pitch outlier filtering| process|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing pitch salience|| guessUnvoiced:| bool ∈ {false,true} (default = false)| estimate pitch for non-voiced segments by using non-salient contours when| no salient ones are present in a frame|| harmonicWeight:| real ∈ (0,1) (default = 0.800000011921)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| hopSize:| integer ∈ (0,inf) (default = 128)| the hop size with which the pitch salience function was computed|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter for the salience function (=0 for maximum| compression, =1 for no compression)|| magnitudeThreshold:| integer ∈ [0,inf) (default = 40)| spectral peak magnitude threshold (maximum allowed difference from the| highest peak in dBs)|| maxFrequency:| real ∈ [0,inf) (default = 20000)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks above) [Hz]|| minDuration:| integer ∈ (0,inf) (default = 100)| the minimum allowed contour duration [ms]|| minFrequency:| real ∈ [0,inf) (default = 80)| the minimum allowed frequency for salience function peaks (ignore contours| with peaks below) [Hz]|| numberHarmonics:| integer ∈ [1,inf) (default = 20)| number of considered harmonics|| peakDistributionThreshold:| real ∈ [0,2] (default = 0.899999976158)| allowed deviation below the peak salience mean over all frames (fraction of| the standard deviation)|| peakFrameThreshold:| real ∈ [0,1] (default = 0.899999976158)| per-frame salience threshold factor (fraction of the highest peak salience| in a frame)|| pitchContinuity:| real ∈ [0,inf) (default = 27.5625)| pitch continuity cue (maximum allowed pitch change during 1 ms time period)| [cents]|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent conversion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| timeContinuity:| integer ∈ (0,inf) (default = 100)| time continuity cue (the maximum allowed gap duration for a pitch contour)| [ms]|| voiceVibrato:| bool ∈ {true,false} (default = false)| detect voice vibrato|| voicingTolerance:| real ∈ [-1.0,1.4] (default = 0.20000000298)| allowed deviation below the average contour mean salience of all contours| (fraction of the standard deviation)||| Description:|| This algorithm estimates the fundamental frequency of the predominant melody| from polyphonic music signals using the MELODIA algorithm. It is specifically| suited for music with a predominent melodic element, for example the singing| voice melody in an accompanied singing recording. The approach [1] is based| on the creation and characterization of pitch contours, time continuous| sequences of pitch candidates grouped using auditory streaming cues. It| furthermore determines for each frame, if the predominant melody is present| or not. To this end, PitchSalienceFunction, PitchSalienceFunctionPeaks,| PitchContours, and PitchContoursMelody algorithms are employed. It is| strongly advised to use the default parameter values which are optimized| according to [1] (where further details are provided) except for| minFrequency, maxFrequency, and voicingTolerance, which will depend on your| application.|| The output is a vector of estimated melody pitch values and a vector of| confidence values. The first value corresponds to the beginning of the input| signal (time 0).|| It is recommended to apply EqualLoudness on the input signal (see [1]) as a| pre-processing stage before running this algorithm.|| Note that "pitchConfidence" can be negative in the case of| "guessUnvoiced"=True: the absolute values represent the confidence, negative| values correspond to segments for which non-salient contours where selected,| zero values correspond to non-voiced segments.|| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| [2] http://mtg.upf.edu/technologies/melodia|| [3] http://www.justinsalamon.com/melody-extraction|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RMS = class Algo(Algorithm)| RMS||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] rms - the root mean square of the input array||| Description:|| This algorithm computes the root mean square (quadratic mean) of an array.| RMS is not defined for empty arrays. In such case, an exception will be| thrown| .| References:| [1] Root mean square - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Root_mean_square|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RawMoments = class Algo(Algorithm)| RawMoments||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] rawMoments - the (raw) moments of the input array||| Parameters:|| range:| real ∈ (0,inf) (default = 22050)| the range of the input array, used for normalizing the results||| Description:|| This algorithm computes the first 5 raw moments of an array. The output array| is of size 6 because the zero-ith moment is used for padding so that the| first moment corresponds to index 1.|| Note:| This algorithm has a range parameter, which usually represents a frequency| (results will range from 0 to range). For a spectral centroid, the range| should be equal to samplerate / 2. For an audio centroid, the frequency range| should be equal to (audio_size-1) / samplerate.|| An exception is thrown if the input array's size is smaller than 2.|| References:| [1] Raw Moment -- from Wolfram MathWorld,| http://mathworld.wolfram.com/RawMoment.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ReplayGain = class Algo(Algorithm)| ReplayGain||| Inputs:|| [vector_real] signal - the input audio signal (must be longer than 0.05ms)||| Outputs:|| [real] replayGain - the distance to the suitable average replay level (~-31dbB) defined by SMPTE [dB]||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the input audio signal [Hz]||| Description:|| This algorithm computes the Replay Gain loudness value of an audio signal.| The algorithm is described in detail in [1]. The value returned is the| 'standard' ReplayGain value, not the value with 6dB preamplification as| computed by lame, mp3gain, vorbisgain, and all widely used ReplayGain| programs.|| This algorithm is only defined for input signals which size is larger than| 0.05ms, otherwise an exception will be thrown.|| As a pre-processing step, the algorithm applies equal-loudness filtering to| the input signal. This is always done in the standard mode, but it can be| turned off in the streaming mode, which is useful in the case one already has| an equal-loudness filtered signal.|| References:| [1] ReplayGain 1.0 specification,| https://wiki.hydrogenaud.io/index.php?title=ReplayGain_1.0_specification|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Loudness/dynamics', 'description': 'This al...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Resample = class Algo(Algorithm)| Resample||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the resampled signal||| Parameters:|| inputSampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the input signal [Hz]|| outputSampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the output signal [Hz]|| quality:| integer ∈ [0,4] (default = 1)| the quality of the conversion, 0 for best quality||| Description:|| This algorithm resamples the input signal to the desired sampling rate.|| This algorithm is only supported if essentia has been compiled with| Real=float, otherwise it will throw an exception. It may also throw an| exception if there is an internal error in the SRC library during conversion.|| References:| [1] Secret Rabbit Code, http://www.mega-nerd.com/SRC|| [2] Resampling - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Resampling|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm r...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ResampleFFT = class Algo(Algorithm)| ResampleFFT||| Inputs:|| [vector_real] input - input array||| Outputs:|| [vector_real] output - output resample array||| Parameters:|| inSize:| integer ∈ [1,inf) (default = 128)| the size of the input sequence. It needss to be even-sized.|| outSize:| integer ∈ [1,inf) (default = 128)| the size of the output sequence. It needss to be even-sized.||| Description:|| This algorithm resamples a sequence using FFT / IFFT. The input and output| sizes must be an even number. (It is meant to be eqivalent to the resample| function in Numpy).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RhythmDescriptors = class Algo(Algorithm)| RhythmDescriptors||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] beats_position - See RhythmExtractor2013 algorithm documentation| [real] confidence - See RhythmExtractor2013 algorithm documentation| [real] bpm - See RhythmExtractor2013 algorithm documentation| [vector_real] bpm_estimates - See RhythmExtractor2013 algorithm documentation| [vector_real] bpm_intervals - See RhythmExtractor2013 algorithm documentation| [real] first_peak_bpm - See BpmHistogramDescriptors algorithm documentation| [real] first_peak_spread - See BpmHistogramDescriptors algorithm documentation| [real] first_peak_weight - See BpmHistogramDescriptors algorithm documentation| [real] second_peak_bpm - See BpmHistogramDescriptors algorithm documentation| [real] second_peak_spread - See BpmHistogramDescriptors algorithm documentation| [real] second_peak_weight - See BpmHistogramDescriptors algorithm documentation| [vector_real] histogram - bpm histogram [bpm]||| Description:|| This algorithm computes rhythm features (bpm, beat positions, beat histogram| peaks) for an audio signal. It combines RhythmExtractor2013 for beat tracking| and BPM estimation with BpmHistogramDescriptors algorithms.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RhythmExtractor = class Algo(Algorithm)| RhythmExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [real] bpm - the tempo estimation [bpm]| [vector_real] ticks - the estimated tick locations [s]| [vector_real] estimates - the bpm estimation per frame [bpm]| [vector_real] bpmIntervals - list of beats interval [s]||| Parameters:|| frameHop:| integer ∈ (0,inf) (default = 1024)| the number of feature frames separating two evaluations|| frameSize:| integer ∈ (0,inf) (default = 1024)| the number audio samples used to compute a feature|| hopSize:| integer ∈ (0,inf) (default = 256)| the number of audio samples per features|| lastBeatInterval:| real ∈ [0,inf) (default = 0.10000000149)| the minimum interval between last beat and end of file [s]|| maxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| minTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]|| numberFrames:| integer ∈ (0,inf) (default = 1024)| the number of feature frames to buffer on|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| tempoHints:| vector_real (default = [])| the optional list of initial beat locations, to favor the detection of| pre-determined tempo period and beats alignment [s]|| tolerance:| real ∈ [0,inf) (default = 0.239999994636)| the minimum interval between two consecutive beats [s]|| useBands:| bool ∈ {true,false} (default = true)| whether or not to use band energy as periodicity function|| useOnset:| bool ∈ {true,false} (default = true)| whether or not to use onsets as periodicity function||| Description:|| This algorithm estimates the tempo in bpm and beat positions given an audio| signal. The algorithm combines several periodicity functions and estimates| beats using TempoTap and TempoTapTicks. It combines:| - onset detection functions based on high-frequency content (see| OnsetDetection)| - complex-domain spectral difference function (see OnsetDetection)| - periodicity function based on energy bands (see FrequencyBands,| TempoScaleBands)|| Note that this algorithm is outdated in terms of beat tracking accuracy, and| it is highly recommended to use RhythmExtractor2013 instead.|| Quality: outdated (use RhythmExtractor2013 instead).|| An exception is thrown if neither "useOnset" nor "useBands" are enabled (i.e.| set to true).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RhythmExtractor2013 = class Algo(Algorithm)| RhythmExtractor2013||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [real] bpm - the tempo estimation [bpm]| [vector_real] ticks - the estimated tick locations [s]| [real] confidence - confidence with which the ticks are detected (ignore this value if using 'degara' method)| [vector_real] estimates - the list of bpm estimates characterizing the bpm distribution for the signal [bpm]| [vector_real] bpmIntervals - list of beats interval [s]||| Parameters:|| maxTempo:| integer ∈ [60,250] (default = 208)| the fastest tempo to detect [bpm]|| method:| string ∈ {multifeature,degara} (default = "multifeature")| the method used for beat tracking|| minTempo:| integer ∈ [40,180] (default = 40)| the slowest tempo to detect [bpm]||| Description:|| This algorithm extracts the beat positions and estimates their confidence as| well as tempo in bpm for an audio signal. The beat locations can be computed| using:| - 'multifeature', the BeatTrackerMultiFeature algorithm| - 'degara', the BeatTrackerDegara algorithm (note that there is no| confidence estimation for this method, the output confidence value is always| 0)|| See BeatTrackerMultiFeature and BeatTrackerDegara algorithms for more| details.|| Note that the algorithm requires the sample rate of the input signal to be| 44100 Hz in order to work correctly.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm ext...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RhythmTransform = class Algo(Algorithm)| RhythmTransform||| Inputs:|| [vector_vector_real] melBands - the energies in the mel bands||| Outputs:|| [vector_vector_real] rhythm - consecutive frames in the rhythm domain||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 256)| the frame size to compute the rhythm trasform|| hopSize:| integer ∈ (0,inf) (default = 32)| the hop size to compute the rhythm transform||| Description:|| This algorithm implements the rhythm transform. It computes a tempogram, a| representation of rhythmic periodicities in the input signal in the rhythm| domain, by using FFT similarly to computation of spectrum in the frequency| domain [1]. Additional features, including rhythmic centroid and a rhythmic| counterpart of MFCCs, can be derived from this rhythmic representation.|| The algorithm relies on a time sequence of frames of Mel bands energies as an| input (see MelBands), but other types of frequency bands can be used as well| (see BarkBands, ERBBands, FrequencyBands). For each band, the derivative of| the frame to frame energy evolution is computed, and the periodicity of the| resulting signal is computed: the signal is cut into frames of "frameSize"| size and is analyzed with FFT. For each frame, the obtained power spectrums| are summed across all bands forming a frame of rhythm transform values.|| Quality: experimental (non-reliable, poor accuracy according to tests on| simple loops, more tests are necessary)|| References:| [1] E. Guaus and P. Herrera, "The rhythm transform: towards a generic| rhythm description," in International Computer Music Conference| (ICMC’05),| 2005.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm imp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).RollOff = class Algo(Algorithm)| RollOff||| Inputs:|| [vector_real] spectrum - the input audio spectrum (must have more than one elements)||| Outputs:|| [real] rollOff - the roll-off frequency [Hz]||| Parameters:|| cutoff:| real ∈ (0,1) (default = 0.850000023842)| the ratio of total energy to attain before yielding the roll-off frequency|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal (used to normalize rollOff) [Hz]||| Description:|| This algorithm computes the roll-off frequency of a spectrum. The roll-off| frequency is defined as the frequency under which some percentage (cutoff) of| the total energy of the spectrum is contained. The roll-off frequency can be| used to distinguish between harmonic (below roll-off) and noisy sounds (above| roll-off).|| An exception is thrown if the input audio spectrum is smaller than 2.| References:| [1] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SBic = class Algo(Algorithm)| SBic||| Inputs:|| [matrix_real] features - extracted features matrix (rows represent features, and columns represent frames of audio)||| Outputs:|| [vector_real] segmentation - a list of frame indices that indicate where a segment of audio begins/ends (the indices of the first and last frame are also added to the list at the beginning and end, respectively)||| Parameters:|| cpw:| real ∈ [0,inf) (default = 1.5)| complexity penalty weight|| inc1:| integer ∈ [1,inf) (default = 60)| first pass increment [frames]|| inc2:| integer ∈ [1,inf) (default = 20)| second pass increment [frames]|| minLength:| integer ∈ [1,inf) (default = 10)| minimum length of a segment [frames]|| size1:| integer ∈ [1,inf) (default = 300)| first pass window size [frames]|| size2:| integer ∈ [1,inf) (default = 200)| second pass window size [frames]||| Description:|| This algorithm segments audio using the Bayesian Information Criterion given| a matrix of frame features. The algorithm searches homogeneous segments for| which the feature vectors have the same probability distribution based on the| implementation in [1]. The input matrix is assumed to have features along| dim1 (horizontal) while frames along dim2 (vertical).|| The segmentation is done in three phases: coarse segmentation, fine| segmentation and segment validation. The first phase uses parameters 'size1'| and 'inc1' to perform BIC segmentation. The second phase uses parameters| 'size2' and 'inc2' to perform a local search for segmentation around the| segmentation done by the first phase. Finally, the validation phase verifies| that BIC differentials at segmentation points are positive as well as filters| out any segments that are smaller than 'minLength'.|| Because this algorithm takes as input feature vectors of frames, all units| are in terms of frames. For example, if a 44100Hz audio signal is segmented| as [0, 99, 199] with a frame size of 1024 and a hopsize of 512, this means,| in the time domain, that the audio signal is segmented at [0s, 99*512/44100s,| 199*512/44100s].|| An exception is thrown if the input only contains one frame of features (i.e.| second dimension is less than 2).|| References:| [1] Audioseg, http://audioseg.gforge.inria.fr|| [2] G. Gravier, M. Betser, and M. Ben, Audio Segmentation Toolkit,| release 1.2, 2010. Available online:| https://gforge.inria.fr/frs/download.php/25187/audioseg-1.2.pdf|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Segmentation', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SNR = class Algo(Algorithm)| SNR||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [real] instantSNR - SNR value for the the current frame| [real] averagedSNR - averaged SNR through an Exponential Moving Average filter| [vector_real] spectralSNR - instant SNR for each frequency bin||| Parameters:|| MAAlpha:| real ∈ [0,1] (default = 0.949999988079)| Alpha coefficient for the EMA SNR estimation [2]|| MMSEAlpha:| real ∈ [0,1] (default = 0.980000019073)| Alpha coefficient for the MMSE estimation [1].|| NoiseAlpha:| real ∈ [0,1] (default = 0.899999976158)| Alpha coefficient for the EMA noise estimation [2]|| frameSize:| integer ∈ (1,inf) (default = 512)| the size of the input frame|| noiseThreshold:| real ∈ (-inf,0] (default = -40)| Threshold to detect frames without signal|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| useBroadbadNoiseCorrection:| bool ∈ {true,false} (default = true)| flag to apply the -10 * log10(BW) broadband noise correction factor||| Description:|| This algorithm computes the SNR of the input audio in a frame-wise manner.| The algorithm assumes that:| 1. The noise is gaussian.| 2. There is a region of noise (without signal) at the beginning of the| stream in order to estimate the PSD of the noise.[1]| Once the noise PSD is estimated, the algorithm relies on the Ephraim-Malah| [2] recursion to estimate the SNR for each frequency bin.| The algorithm also returns an overall (a single value for the whole spectrum)| SNR estimation and an averaged overall SNR estimation using Exponential| Moving Average filtering.| This algorithm throws a Warning if less than 15 frames are used to estimte| the noise PSD.|| References:| [1] Vaseghi, S. V. (2008). Advanced digital signal processing and noise| reduction. John Wiley & Sons. Page 336.| [2] Ephraim, Y., & Malah, D. (1984). Speech enhancement using a| minimum-mean square error short-time spectral amplitude estimator. IEEE| Transactions on acoustics, speech, and signal processing, 32(6), 1109-1121.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SaturationDetector = class Algo(Algorithm)| SaturationDetector||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] starts - starting times of the detected saturated regions [s]| [vector_real] ends - ending times of the detected saturated regions [s]||| Parameters:|| differentialThreshold:| real ∈ [0,inf)) (default = 0.0010000000475)| minimum difference between contiguous samples of the salturated regions|| energyThreshold:| real ∈ (-inf,0]) (default = -1)| mininimum energy of the samples in the saturated regions [dB]|| frameSize:| integer ∈ (0,inf) (default = 512)| expected input frame size|| hopSize:| integer ∈ (0,inf) (default = 256)| hop size used for the analysis|| minimumDuration:| real ∈ [0,inf)) (default = 0.00499999988824)| minimum duration of the saturated regions [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| sample rate used for the analysis||| Description:|| this algorithm outputs the staring/ending locations of the saturated regions| in seconds. Saturated regions are found by means of a tripe criterion:| 1. samples in a saturated region should have more energy than a given| threshold.| 2. the difference between the samples in a saturated region should be| smaller than a given threshold.| 3. the duration of the saturated region should be longer than a given| threshold.|| note: The algorithm was designed for a framewise use and the returned| timestamps are related to the first frame processed. Use reset() or| configure() to restart the count.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'this algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Scale = class Algo(Algorithm)| Scale||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] signal - the output audio signal||| Parameters:|| clipping:| bool ∈ {true,false} (default = true)| boolean flag whether to apply clipping or not|| factor:| real ∈ [0,inf) (default = 10)| the multiplication factor by which the audio will be scaled|| maxAbsValue:| real ∈ [0,inf) (default = 1)| the maximum value above which to apply clipping||| Description:|| This algorithm scales the audio by the specified factor using clipping if| required.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm s...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SilenceRate = class Algo(Algorithm)| SilenceRate||| Inputs:|| [vector_real] frame - the input frame||| Parameters:|| thresholds:| vector_real (default = [])| the threshold values||| Description:|| This algorithm estimates if a frame is silent. Given a list of thresholds,| this algorithm creates a equally-sized list of outputs and returns 1 on a| given output whenever the instant power of the input frame is below the given| output's respective threshold, and returns 0 otherwise. This is done for each| frame with respect to all outputs. In other words, if a given frame's instant| power is below several given thresholds, then each of the corresponding| outputs will emit a 1.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Duration/silence', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SineModelAnal = class Algo(Algorithm)| SineModelAnal||| Inputs:|| [vector_complex] fft - the input frame||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks||| Parameters:|| freqDevOffset:| real ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| magnitudeThreshold:| real ∈ (-inf,inf) (default = -74)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 22050)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 250)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ [0,inf) (default = 0)| the minimum frequency of the range to evaluate [Hz]|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the sine model analysis.|| It is recommended that the input "spectrum" be computed by the Spectrum| algorithm. This algorithm uses PeakDetection. See documentation for possible| exceptions and input requirements on input "spectrum".|| References:| [1] Peak Detection,| http://ccrma.stanford.edu/~jos/parshl/Peak_Detection_Steps_3.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SineModelSynth = class Algo(Algorithm)| SineModelSynth||| Inputs:|| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] phases - the phases of the sinusoidal peaks||| Outputs:|| [vector_complex] fft - the output FFT frame||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the output FFT frame (full spectrum size)|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the sine model synthesis from sine model analysis.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SineSubtraction = class Algo(Algorithm)| SineSubtraction||| Inputs:|| [vector_real] frame - the input audio frame to subtract from| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] phases - the phases of the sinusoidal peaks||| Outputs:|| [vector_real] frame - the output audio frame||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 512)| the size of the FFT internal process (full spectrum size) and output frame.| Minimum twice the hopsize.|| hopSize:| integer ∈ [1,inf) (default = 128)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm subtracts the sinusoids computed with the sine model analysis| from an input audio signal. It ouputs an audio signal.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SingleBeatLoudness = class Algo(Algorithm)| SingleBeatLoudness||| Inputs:|| [vector_real] beat - audio segement containing a beat||| Outputs:|| [real] loudness - the beat's energy across the whole spectrum| [vector_real] loudnessBandRatio - the beat's energy ratio for each band||| Parameters:|| beatDuration:| real ∈ (0,inf) (default = 0.0500000007451)| window size for the beat's energy computation (the window starts at the| onset) [s]|| beatWindowDuration:| real ∈ (0,inf) (default = 0.10000000149)| window size for the beat's onset detection [s]|| frequencyBands:| vector_real (default = [0, 200, 400, 800, 1600, 3200, 22000])| frequency bands|| onsetStart:| string ∈ {sumEnergy, peakEnergy} (default = "sumEnergy")| criteria for finding the start of the beat|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the spectrum energy of a single beat across the whole| frequency range and on each specified frequency band given an audio segment.| It detects the onset of the beat within the input segment, computes spectrum| on a window starting on this onset, and estimates energy (see Energy and| EnergyBandRatio algorithms). The frequency bands used by default are: 0-200| Hz, 200-400 Hz, 400-800 Hz, 800-1600 Hz, 1600-3200 Hz, 3200-22000Hz,| following E. Scheirer [1].|| This algorithm throws an exception either when parameter beatDuration is| larger than beatWindowSize or when the size of the input beat segment is less| than beatWindowSize plus beatDuration.|| References:| [1] E. D. Scheirer, "Tempo and beat analysis of acoustic musical signals,"| The Journal of the Acoustical Society of America, vol. 103, p. 588, 1998.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SingleGaussian = class Algo(Algorithm)| SingleGaussian||| Inputs:|| [matrix_real] matrix - the input data matrix (e.g. the MFCC descriptor over frames)||| Outputs:|| [vector_real] mean - the mean of the values| [matrix_real] covariance - the covariance matrix| [matrix_real] inverseCovariance - the inverse of the covariance matrix||| Description:|| This algorithm estimates the single gaussian distribution for a matrix of| feature vectors. For example, using the single gaussian on descriptors like| MFCC with the symmetric Kullback-Leibler divergence might be a much better| option than just the mean and variance of the descriptors over a whole| signal.|| An exception is thrown if the covariance of the input matrix is singular or| if the input matrix is empty.|| References:| [1] E. Pampalk, "Computational models of music similarity and their| application in music information retrieval,” Vienna University of| Technology, 2006.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Slicer = class Algo(Algorithm)| Slicer||| Inputs:|| [vector_real] audio - the input audio signal||| Outputs:|| [vector_vector_real] frame - the frames of the sliced input signal||| Parameters:|| endTimes:| vector_real (default = [])| the list of end times for the slices you want to extract|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| startTimes:| vector_real (default = [])| the list of start times for the slices you want to extract|| timeUnits:| string ∈ {samples,seconds} (default = "seconds")| the units of time of the start and end times||| Description:|| This algorithm splits an audio signal into segments given their start and end| times.|| The parameters, "startTimes" and "endTimes" must be coherent. If these| parameters differ in size, an exception is thrown. If a particular startTime| is larger than its corresponding endTime, an exception is thrown.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm s...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectralCentroidTime = class Algo(Algorithm)| SpectralCentroidTime||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] centroid - the spectral centroid of the signal||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| sampling rate of the input spectrum [Hz]||| Description:|| This algorithm computes the spectral centroid of a signal in time domain. A| first difference filter is applied to the input signal. Then the centroid is| computed by dividing the norm of the resulting signal by the norm of the| input signal. The centroid is given in hertz.| References:| [1] Udo Zölzer (2002). DAFX Digital Audio Effects pag.364-365|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectralComplexity = class Algo(Algorithm)| SpectralComplexity||| Inputs:|| [vector_real] spectrum - the input spectrum||| Outputs:|| [real] spectralComplexity - the spectral complexity of the input spectrum||| Parameters:|| magnitudeThreshold:| real ∈ [0,inf) (default = 0.00499999988824)| the minimum spectral-peak magnitude that contributes to spectral complexity|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the spectral complexity of a spectrum. The spectral| complexity is based on the number of peaks in the input spectrum.|| It is recommended that the input "spectrum" be computed by the Spectrum| algorithm. The input "spectrum" is passed to the SpectralPeaks algorithm and| thus inherits its input requirements and exceptions.| References:| [1] C. Laurier, O. Meyers, J. Serrà, M. Blech, P. Herrera, and X. Serra,| "Indexing music by mood: design and integration of an automatic| content-based annotator," Multimedia Tools and Applications, vol. 48,| no. 1, pp. 161–184, 2009.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectralContrast = class Algo(Algorithm)| SpectralContrast||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] spectralContrast - the spectral contrast coefficients| [vector_real] spectralValley - the magnitudes of the valleys||| Parameters:|| frameSize:| integer ∈ [2,inf) (default = 2048)| the size of the fft frames|| highFrequencyBound:| real ∈ (0,inf) (default = 11000)| the upper bound of the highest band|| lowFrequencyBound:| real ∈ (0,inf) (default = 20)| the lower bound of the lowest band|| neighbourRatio:| real ∈ (0,1] (default = 0.40000000596)| the ratio of the bins in the sub band used to calculate the peak and valley|| numberBands:| integer ∈ (0,inf) (default = 6)| the number of bands in the filter|| sampleRate:| real ∈ (0,inf) (default = 22050)| the sampling rate of the audio signal|| staticDistribution:| real ∈ [0,1] (default = 0.15000000596)| the ratio of the bins to distribute equally||| Description:|| This algorithm computes the Spectral Contrast feature of a spectrum. It is| based on the Octave Based Spectral Contrast feature as described in [1]. The| version implemented here is a modified version to improve discriminative| power and robustness. The modifications are described in [2].|| References:| [1] D.-N. Jiang, L. Lu, H.-J. Zhang, J.-H. Tao, and L.-H. Cai, "Music type| classification by spectral contrast feature," in IEEE International| Conference on Multimedia and Expo (ICME’02), 2002, vol. 1, pp. 113–116.|| [2] V. Akkermans, J. Serrà, and P. Herrera, "Shape-based spectral contrast| descriptor," in Sound and Music Computing Conference (SMC’09), 2009,| pp. 143–148.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectralPeaks = class Algo(Algorithm)| SpectralPeaks||| Inputs:|| [vector_real] spectrum - the input spectrum||| Outputs:|| [vector_real] frequencies - the frequencies of the spectral peaks [Hz]| [vector_real] magnitudes - the magnitudes of the spectral peaks||| Parameters:|| magnitudeThreshold:| real ∈ (-inf,inf) (default = 0)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| minFrequency:| real ∈ [0,inf) (default = 0)| the minimum frequency of the range to evaluate [Hz]|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm extracts peaks from a spectrum. It is important to note that| the peak algorithm is independent of an input that is linear or in dB, so one| has to adapt the threshold to fit with the type of data fed to it. The| algorithm relies on PeakDetection algorithm which is run with parabolic| interpolation [1]. The exactness of the peak-searching depends heavily on the| windowing type. It gives best results with dB input, a blackman-harris 92dB| window and interpolation set to true. According to [1], spectral peak| frequencies tend to be about twice as accurate when dB magnitude is used| rather than just linear magnitude. For further information about the peak| detection, see the description of the PeakDetection algorithm.|| It is recommended that the input "spectrum" be computed by the Spectrum| algorithm. This algorithm uses PeakDetection. See documentation for possible| exceptions and input requirements on input "spectrum".|| References:| [1] Peak Detection,| http://ccrma.stanford.edu/~jos/parshl/Peak_Detection_Steps_3.html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm e...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectralWhitening = class Algo(Algorithm)| SpectralWhitening||| Inputs:|| [vector_real] spectrum - the audio linear spectrum| [vector_real] frequencies - the spectral peaks' linear frequencies| [vector_real] magnitudes - the spectral peaks' linear magnitudes||| Outputs:|| [vector_real] magnitudes - the whitened spectral peaks' linear magnitudes||| Parameters:|| maxFrequency:| real ∈ (0,inf) (default = 5000)| max frequency to apply whitening to [Hz]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| Performs spectral whitening of spectral peaks of a spectrum. The algorithm| works in dB scale, but the conversion is done by the algorithm so input| should be in linear scale. The concept of 'whitening' refers to 'white noise'| or a non-zero flat spectrum. It first computes a spectral envelope similar to| the 'true envelope' in [1], and then modifies the amplitude of each peak| relative to the envelope. For example, the predominant peaks will have a| value close to 0dB because they are very close to the envelope. On the other| hand, minor peaks between significant peaks will have lower amplitudes such| as -30dB.|| The input "frequencies" and "magnitudes" can be computed using the| SpectralPeaks algorithm.|| An exception is thrown if the input frequency and magnitude input vectors are| of different size.|| References:| [1] A. Röbel and X. Rodet, "Efficient spectral envelope estimation and its| application to pitch shifting and envelope preservation," in International| Conference on Digital Audio Effects (DAFx’05), 2005.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'Performs spectra...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Spectrum = class Algo(Algorithm)| Spectrum||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] spectrum - magnitude spectrum of the input audio signal||| Parameters:|| size:| integer ∈ [1,inf) (default = 2048)| the expected size of the input audio signal (this is an optional parameter| to optimize memory allocation)||| Description:|| This algorithm computes the magnitude spectrum of an array of Reals. The| resulting magnitude spectrum has a size which is half the size of the input| array plus one. Bins contain raw (linear) magnitude values.|| References:| [1] Frequency spectrum - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Frequency_spectrum|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectrumCQ = class Algo(Algorithm)| SpectrumCQ||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] spectrumCQ - the magnitude constant-Q spectrum||| Parameters:|| binsPerOctave:| integer ∈ [1,inf) (default = 12)| number of bins per octave|| minFrequency:| real ∈ [1,inf) (default = 32.7000007629)| minimum frequency [Hz]|| minimumKernelSize:| integer ∈ [2,inf) (default = 4)| minimum size allowed for frequency kernels|| numberBins:| integer ∈ [1,inf) (default = 84)| number of frequency bins, starting at minFrequency|| sampleRate:| real ∈ [0,inf) (default = 44100)| FFT sampling rate [Hz]|| scale:| real ∈ [0,inf) (default = 1)| filters scale. Larger values use longer windows|| threshold:| real ∈ [0,1) (default = 0.00999999977648)| bins whose magnitude is below this quantile are discarded|| windowType:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'|| zeroPhase:| bool ∈ {true,false} (default = true)| a boolean value that enables zero-phase windowing. Input audio frames| should be windowed with the same phase mode||| Description:|| This algorithm computes the magnitude of the Constant-Q spectrum. See| ConstantQ algorithm for more details.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpectrumToCent = class Algo(Algorithm)| SpectrumToCent||| Inputs:|| [vector_real] spectrum - the input spectrum (must be greater than size one)||| Outputs:|| [vector_real] bands - the energy in each band| [vector_real] frequencies - the central frequency of each band||| Parameters:|| bands:| integer ∈ [1,inf) (default = 720)| number of bins to compute. Default is 720 (6 octaves with the default| 'centBinResolution')|| centBinResolution:| real ∈ (0,inf) (default = 10)| Width of each band in cents. Default is 10 cents|| inputSize:| integer ∈ (1,inf) (default = 32768)| the size of the spectrum|| log:| bool ∈ {true,false} (default = true)| compute log-energies (log10 (1 + energy))|| minimumFrequency:| real ∈ (0, inf) (default = 164)| central frequency of the first band of the bank [Hz]|| normalize:| string ∈ {unit_sum,unit_max} (default = "unit_sum")| use unit area or vertex equal to 1 triangles.|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum||| Description:|| This algorithm computes energy in triangular frequency bands of a spectrum| equally spaced on the cent scale. Each band is computed to have a constant| wideness in the cent scale. For each band the power-spectrum (mag-squared) is| summed.|| Parameter "centBinResolution" should be and integer greater than 1, otherwise| an exception will be thrown. TriangularBands is only defined for spectrum,| which size is greater than 1.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Spline = class Algo(Algorithm)| Spline||| Inputs:|| [real] x - the input coordinate (x-axis)||| Outputs:|| [real] y - the value of the spline at x||| Parameters:|| beta1:| real ∈ [0,inf] (default = 1)| the skew or bias parameter (only available for type beta)|| beta2:| real ∈ [0,inf) (default = 0)| the tension parameter|| type:| string ∈ {b,beta,quadratic} (default = "b")| the type of spline to be computed|| xPoints:| vector_real (default = [0, 1])| the x-coordinates where data is specified (the points must be arranged in| ascending order and cannot contain duplicates)|| yPoints:| vector_real (default = [0, 1])| the y-coordinates to be interpolated (i.e. the known data)||| Description:|| Evaluates a piecewise spline of type b, beta or quadratic.| The input value, i.e. the point at which the spline is to be evaluated| typically should be between xPoins[0] and xPoinst[size-1]. If the value lies| outside this range, extrapolation is used.| Regarding spline types:| - B: evaluates a cubic B spline approximant.| - Beta: evaluates a cubic beta spline approximant. For beta splines| parameters 'beta1' and 'beta2' can be supplied. For no bias set beta1 to 1| and for no tension set beta2 to 0. Note that if beta1=1 and beta2=0, the| cubic beta becomes a cubic B spline. On the other hand if beta1=1 and beta2| is large the beta spline turns into a linear spline.| - Quadratic: evaluates a piecewise quadratic spline at a point. Note that| size of input must be odd.|| References:| [1] Spline interpolation - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Spline_interpolation|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'Evaluates a piec...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SprModelAnal = class Algo(Algorithm)| SprModelAnal||| Inputs:|| [vector_real] frame - the input frame||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] res - output residual frame||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| freqDevOffset:| integer ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| magnitudeThreshold:| real ∈ (-inf,inf) (default = 0)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ [0,inf) (default = 0)| the minimum frequency of the range to evaluate [Hz]|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the sinusoidal plus residual model analysis.|| It is recommended that the input "spectrum" be computed by the Spectrum| algorithm. This algorithm uses SineModelAnal. See documentation for possible| exceptions and input requirements on input "spectrum".|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SprModelSynth = class Algo(Algorithm)| SprModelSynth||| Inputs:|| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] res - the residual frame||| Outputs:|| [vector_real] frame - the output audio frame of the Sinusoidal Plus Stochastic model| [vector_real] sineframe - the output audio frame for sinusoidal component| [vector_real] resframe - the output audio frame for stochastic component||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the output FFT frame (full spectrum size)|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the sinusoidal plus residual model synthesis from SPS| model analysis.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpsModelAnal = class Algo(Algorithm)| SpsModelAnal||| Inputs:|| [vector_real] frame - the input frame||| Outputs:|| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] stocenv - the stochastic envelope||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| freqDevOffset:| integer ∈ (0,inf) (default = 20)| minimum frequency deviation at 0Hz|| freqDevSlope:| real ∈ (-inf,inf) (default = 0.00999999977648)| slope increase of minimum frequency deviation|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| magnitudeThreshold:| real ∈ (-inf,inf) (default = 0)| peaks below this given threshold are not outputted|| maxFrequency:| real ∈ (0,inf) (default = 5000)| the maximum frequency of the range to evaluate [Hz]|| maxPeaks:| integer ∈ [1,inf) (default = 100)| the maximum number of returned peaks|| maxnSines:| integer ∈ (0,inf) (default = 100)| maximum number of sines per frame|| minFrequency:| real ∈ [0,inf) (default = 0)| the minimum frequency of the range to evaluate [Hz]|| orderBy:| string ∈ {frequency,magnitude} (default = "frequency")| the ordering type of the outputted peaks (ascending by frequency or| descending by magnitude)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the stochastic model analysis.|| It is recommended that the input "spectrum" be computed by the Spectrum| algorithm. This algorithm uses SineModelAnal. See documentation for possible| exceptions and input requirements on input "spectrum".|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SpsModelSynth = class Algo(Algorithm)| SpsModelSynth||| Inputs:|| [vector_real] magnitudes - the magnitudes of the sinusoidal peaks| [vector_real] frequencies - the frequencies of the sinusoidal peaks [Hz]| [vector_real] phases - the phases of the sinusoidal peaks| [vector_real] stocenv - the stochastic envelope||| Outputs:|| [vector_real] frame - the output audio frame of the Sinusoidal Plus Stochastic model| [vector_real] sineframe - the output audio frame for sinusoidal component| [vector_real] stocframe - the output audio frame for stochastic component||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the output FFT frame (full spectrum size)|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the sinusoidal plus stochastic model synthesis from| SPS model analysis.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StartStopCut = class Algo(Algorithm)| StartStopCut||| Inputs:|| [vector_real] audio - the input audio||| Outputs:|| [integer] startCut - 1 if there is a cut at the begining of the audio| [integer] stopCut - 1 if there is a cut at the end of the audio||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 256)| the frame size for the internal power analysis|| hopSize:| integer ∈ (0,inf) (default = 256)| the hop size for the internal power analysis|| maximumStartTime:| real ∈ [0,inf)) (default = 10)| if the first non-silent frame occurs before maximumStartTime startCut is| activated [ms]|| maximumStopTime:| real ∈ [0,inf)) (default = 10)| if the last non-silent frame occurs after maximumStopTime to the end| stopCut is activated [ms]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sample rate|| threshold:| integer ∈ (-inf,0]) (default = -60)| the threshold below which average energy is defined as silence [dB]||| Description:|| This algorithm outputs if there is a cut at the beginning or at the end of| the audio by locating the first and last non-silent frames and comparing| their positions to the actual beginning and end of the audio. The input audio| is considered to be cut at the beginning (or the end) and the corresponding| flag is activated if the first (last) non-silent frame occurs before (after)| the configurable time threshold.|| Notes: This algorithm is designed to operate on the entire (file) audio. In| the streaming mode, use it in combination with RealAccumulator.| The encoding/decoding process of lossy formats can introduce some padding at| the beginning/end of the file. E.g. an MP3 file encoded and decoded with LAME| using the default parameters will introduce a delay of 1104 samples| [http://lame.sourceforge.net/tech-FAQ.txt]. In this case, the| maximumStartTime can be increased by 1104 ÷ 44100 × 1000 = 25 ms to prevent| misdetections.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StartStopSilence = class Algo(Algorithm)| StartStopSilence||| Inputs:|| [vector_real] frame - the input audio frames||| Outputs:|| [integer] startFrame - number of the first non-silent frame| [integer] stopFrame - number of the last non-silent frame||| Parameters:|| threshold:| integer ∈ (-inf,0]) (default = -60)| the threshold below which average energy is defined as silence [dB]||| Description:|| This algorithm outputs the frame at which sound begins and the frame at which| sound ends.|| Note: In standard mode the algorithm is to be run iteratively on a sequence| of frames. The outputs are updated on each iteration, and the final result is| produced at the end of the sequence.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Duration/silence', 'description': 'This alg...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StereoDemuxer = class Algo(Algorithm)| StereoDemuxer||| Inputs:|| [vector_stereosample] audio - the audio signal||| Outputs:|| [vector_real] left - the left channel of the audio signal| [vector_real] right - the right channel of the audio signal||| Description:|| This algorithm outputs left and right channel separately given a stereo| signal. If the signal is monophonic, it outputs a zero signal on the right| channel.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm o...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StereoMuxer = class Algo(Algorithm)| StereoMuxer||| Inputs:|| [vector_real] left - the left channel of the audio signal| [vector_real] right - the right channel of the audio signal||| Outputs:|| [vector_stereosample] audio - the audio signal||| Description:|| This algorithm outputs a stereo signal given left and right channel| separately.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm o...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StereoTrimmer = class Algo(Algorithm)| StereoTrimmer||| Inputs:|| [vector_stereosample] signal - the input stereo signal||| Outputs:|| [vector_stereosample] signal - the trimmed stereo signal||| Parameters:|| checkRange:| bool ∈ {true,false} (default = false)| check whether the specified time range for a slice fits the size of input| signal (throw exception if not)|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice you want to extract [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the input audio signal [Hz]|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice you want to extract [s]||| Description:|| This algorithm extracts a segment of a stereo audio signal given its start| and end times.| Giving "startTime" greater than "endTime" will raise an exception.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm e...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StochasticModelAnal = class Algo(Algorithm)| StochasticModelAnal||| Inputs:|| [vector_real] frame - the input frame||| Outputs:|| [vector_real] stocenv - the stochastic envelope||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the stochastic model analysis. It gets the resampled| spectral envelope of the stochastic component.|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StochasticModelSynth = class Algo(Algorithm)| StochasticModelSynth||| Inputs:|| [vector_real] stocenv - the stochastic envelope input||| Outputs:|| [vector_real] frame - the output frame||| Parameters:|| fftSize:| integer ∈ [1,inf) (default = 2048)| the size of the internal FFT size (full spectrum size)|| hopSize:| integer ∈ [1,inf) (default = 512)| the hop size between frames|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| stocf:| real ∈ (0,1] (default = 0.20000000298)| decimation factor used for the stochastic approximation||| Description:|| This algorithm computes the stochastic model synthesis. It generates the| noisy spectrum from a resampled spectral envelope of the stochastic| component.|| References:| https://github.com/MTG/sms-tools| http://mtg.upf.edu/technologies/sms|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Synthesis', 'description': 'This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StrongDecay = class Algo(Algorithm)| StrongDecay||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [real] strongDecay - the strong decay||| Parameters:|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm computes the Strong Decay of an audio signal. The Strong Decay| is built from the non-linear combination of the signal energy and the signal| temporal centroid, the latter being the balance of the absolute value of the| signal. A signal containing a temporal centroid near its start boundary and a| strong energy is said to have a strong decay.|| This algorithm is not defined for zero signals (i.e. silence) nor when the| signal's size is less than two, as it could not compute its centroid.|| References:| [1] F. Gouyon and P. Herrera, "Exploration of techniques for automatic| labeling of audio drum tracks instruments," in MOSART: Workshop on Current| Directions in Computer Music, 2001.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).StrongPeak = class Algo(Algorithm)| StrongPeak||| Inputs:|| [vector_real] spectrum - the input spectrum (must be greater than one element and cannot contain negative values)||| Outputs:|| [real] strongPeak - the Strong Peak ratio||| Description:|| This algorithm computes the Strong Peak of a spectrum. The Strong Peak is| defined as the ratio between the spectrum's maximum peak's magnitude and the| "bandwidth" of the peak above a threshold (half its amplitude). This ratio| reveals whether the spectrum presents a very "pronounced" maximum peak (i.e.| the thinner and the higher the maximum of the spectrum is, the higher the| ratio value).|| Note that "bandwidth" is defined as the width of the peak in the| log10-frequency domain. This is different than as implemented in [1]. Using| the log10-frequency domain allows this algorithm to compare strong peaks at| lower frequencies with those from higher frequencies.|| An exception is thrown if the input spectrum contains less than two elements.|| References:| [1] F. Gouyon and P. Herrera, "Exploration of techniques for automatic| labeling of audio drum tracks instruments,” in MOSART: Workshop on| Current| Directions in Computer Music, 2001.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SuperFluxExtractor = class Algo(Algorithm)| SuperFluxExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] onsets - the onsets times||| Parameters:|| combine:| real ∈ (0,inf) (default = 20)| time threshold for double onsets detections (ms)|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing low-level features|| hopSize:| integer ∈ (0,inf) (default = 256)| the hop size for computing low-level features|| ratioThreshold:| real ∈ [0,inf) (default = 16)| ratio threshold for peak picking with respect to| novelty_signal/novelty_average rate, use 0 to disable it (for low-energy| onsets)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]|| threshold:| real ∈ [0,inf) (default = 0.0500000007451)| threshold for peak peaking with respect to the difference between| novelty_signal and average_signal (for onsets in ambient noise)||| Description:|| This algorithm detects onsets given an audio signal using SuperFlux| algorithm. This implementation is based on the available reference| implementation in python [2]. The algorithm computes spectrum of the input| signal, summarizes it into triangular band energies, and computes a onset| detection function based on spectral flux tracking spectral trajectories with| a maximum filter (SuperFluxNovelty). The peaks of the function are then| detected (SuperFluxPeaks).|| References:| [1] Böck, S. and Widmer, G., Maximum Filter Vibrato Suppression for Onset| Detection, Proceedings of the 16th International Conference on Digital| Audio Effects (DAFx-13), 2013| [2] https://github.com/CPJKU/SuperFlux|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm det...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SuperFluxNovelty = class Algo(Algorithm)| SuperFluxNovelty||| Inputs:|| [vector_vector_real] bands - the input bands spectrogram||| Outputs:|| [real] differences - SuperFlux novelty curve||| Parameters:|| binWidth:| integer ∈ [3,inf) (default = 3)| filter width (number of frequency bins)|| frameWidth:| integer ∈ (0,inf) (default = 2)| differentiation offset (compute the difference with the N-th previous| frame)||| Description:|| Onset detection function for Superflux algorithm. See SuperFluxExtractor for| more details.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'Onset detection fu...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).SuperFluxPeaks = class Algo(Algorithm)| SuperFluxPeaks||| Inputs:|| [vector_real] novelty - the input onset detection function||| Outputs:|| [vector_real] peaks - detected peaks' instants [s]||| Parameters:|| combine:| real ∈ (0,inf) (default = 30)| time threshold for double onsets detections (ms)|| frameRate:| real ∈ (0,inf) (default = 172)| frameRate|| pre_avg:| real ∈ (0,inf) (default = 100)| look back duration for moving average filter [ms]|| pre_max:| real ∈ (0,inf) (default = 30)| look back duration for moving maximum filter [ms]|| ratioThreshold:| real ∈ [0,inf) (default = 16)| ratio threshold for peak picking with respect to| novelty_signal/novelty_average rate, use 0 to disable it (for low-energy| onsets)|| threshold:| real ∈ [0,inf) (default = 0.0500000007451)| threshold for peak peaking with respect to the difference between| novelty_signal and average_signal (for onsets in ambient noise)||| Description:|| This algorithm detects peaks of an onset detection function computed by the| SuperFluxNovelty algorithm. See SuperFluxExtractor for more details.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm det...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TCToTotal = class Algo(Algorithm)| TCToTotal||| Inputs:|| [vector_real] envelope - the envelope of the signal (its length must be greater than 1||| Outputs:|| [real] TCToTotal - the temporal centroid to total length ratio||| Description:|| This algorithm calculates the ratio of the temporal centroid to the total| length of a signal envelope. This ratio shows how the sound is 'balanced'.| Its value is close to 0 if most of the energy lies at the beginning of the| sound (e.g. decrescendo or impulsive sounds), close to 0.5 if the sound is| symetric (e.g. 'delta unvarying' sounds), and close to 1 if most of the| energy lies at the end of the sound (e.g. crescendo sounds).|| Please note that the TCToTotal ratio is not defined for a zero signal (a| signal consisting of only zeros), nor it is defined for a signal of less than| 2 elements.An exception is thrown if the given envelope's size is not larger| than 1. And also if the integral of the input envelope is 0 (i.e. envelope is| only zeros or if its sum is 0).|| This algorithm is intended to be plugged after the Envelope algorithm|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Envelope/SFX', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TempoScaleBands = class Algo(Algorithm)| TempoScaleBands||| Inputs:|| [vector_real] bands - the audio power spectrum divided into bands||| Outputs:|| [vector_real] scaledBands - the output bands after scaling| [real] cumulativeBands - cumulative sum of the output bands before scaling||| Parameters:|| bandsGain:| vector_real (default = [2, 3, 2, 1, 1.20000004768, 2, 3, 2.5])| gain for each bands|| frameTime:| real ∈ (0,inf) (default = 512)| the frame rate in samples||| Description:|| This algorithm computes features for tempo tracking to be used with the| TempoTap algorithm. See standard_rhythmextractor_tempotap in examples folder.|| An exception is thrown if less than 1 band is given. An exception is also| thrown if the there are not an equal number of bands given as band-gains| given.|| Quality: outdated (the associated TempoTap algorithm is outdated, however it| can be potentially used as an onset detection function for other tempo| estimation algorithms although no evaluation has been done)|| References:| [1] Algorithm by Fabien Gouyon and Simon Dixon. There is no reference at| the time of this writing.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm com...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TempoTap = class Algo(Algorithm)| TempoTap||| Inputs:|| [vector_real] featuresFrame - input temporal features of a frame||| Outputs:|| [vector_real] periods - list of tempo estimates found for each input feature, in frames| [vector_real] phases - list of initial phase candidates found for each input feature, in frames||| Parameters:|| frameHop:| integer ∈ (0,inf) (default = 1024)| number of feature frames separating two evaluations|| frameSize:| integer ∈ (0,inf) (default = 256)| number of audio samples in a frame|| maxTempo:| integer ∈ [60,250] (default = 208)| fastest tempo allowed to be detected [bpm]|| minTempo:| integer ∈ [40,180] (default = 40)| slowest tempo allowed to be detected [bpm]|| numberFrames:| integer ∈ (0,inf) (default = 1024)| number of feature frames to buffer on|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| tempoHints:| vector_real (default = [])| optional list of initial beat locations, to favor the detection of| pre-determined tempo period and beats alignment [s]||| Description:|| This algorithm estimates the periods and phases of a periodic signal,| represented by a sequence of values of any number of detection functions,| such as energy bands, onsets locations, etc. It requires to be sequentially| run on a vector of such values ("featuresFrame") for each particular audio| frame in order to get estimations related to that frames. The estimations are| done for each detection function separately, utilizing the latest "frameHop"| frames, including the present one, to compute autocorrelation. Empty| estimations will be returned until enough frames are accumulated in the| algorithm's buffer.| The algorithm uses elements of the following beat-tracking methods:| - BeatIt, elaborated by Fabien Gouyon and Simon Dixon (input features) [1]| - Multi-comb filter with Rayleigh weighting, Mathew Davies [2]|| Parameter "maxTempo" should be 20bpm larger than "minTempo", otherwise an| exception is thrown. The same applies for parameter "frameHop", which should| not be greater than numberFrames. If the supplied "tempoHints" did not match| any realistic bpm value, an exeception is thrown.|| This algorithm is thought to provide the input for TempoTapTicks algorithm.| The "featureFrame" vectors can be formed by Multiplexer algorithm in the case| of combining different features.|| Quality: outdated (use TempoTapDegara instead)|| References:| [1] F. Gouyon, "A computational approach to rhythm description: Audio| features for the computation of rhythm periodicity functions and their use| in tempo induction and music content processing," UPF, Barcelona, Spain,| 2005.|| [2] M. Davies and M. Plumbley, "Causal tempo tracking of audio," in| International Symposium on Music Information Retrieval (ISMIR'04), 2004.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': "This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TempoTapDegara = class Algo(Algorithm)| TempoTapDegara||| Inputs:|| [vector_real] onsetDetections - the input frame-wise vector of onset detection values||| Outputs:|| [vector_real] ticks - the list of resulting ticks [s]||| Parameters:|| maxTempo:| integer ∈ [60,250] (default = 208)| fastest tempo allowed to be detected [bpm]|| minTempo:| integer ∈ [40,180] (default = 40)| slowest tempo allowed to be detected [bpm]|| resample:| string ∈ {none,x2,x3,x4} (default = "none")| use upsampling of the onset detection function (may increase accuracy)|| sampleRateODF:| real ∈ (0,inf) (default = 86.1328125)| the sampling rate of the onset detection function [Hz]||| Description:|| This algorithm estimates beat positions given an onset detection function.| The detection function is partitioned into 6-second frames with a 1.5-second| increment, and the autocorrelation is computed for each frame, and is| weighted by a tempo preference curve [2]. Periodicity estimations are done| frame-wisely, searching for the best match with the Viterbi algorith [3]. The| estimated periods are then passed to the probabilistic beat tracking| algorithm [1], which computes beat positions.|| Note that the input values of the onset detection functions must be| non-negative otherwise an exception is thrown. Parameter "maxTempo" should be| 20bpm larger than "minTempo", otherwise an exception is thrown.|| References:| [1] Degara, N., Rua, E. A., Pena, A., Torres-Guijarro, S., Davies, M. E., &| Plumbley, M. D. (2012). Reliability-informed beat tracking of musical| signals. Audio, Speech, and Language Processing, IEEE Transactions on, 20(1),| 290-301.| [2] Davies, M. E., & Plumbley, M. D. (2007). Context-dependent beat| tracking of musical audio. Audio, Speech, and Language Processing, IEEE| Transactions on, 15(3), 1009-1020.| [3] Stark, A. M., Davies, M. E., & Plumbley, M. D. (2009, September).| Real-time beatsynchronous analysis of musical audio. In 12th International| Conference on Digital Audio Effects (DAFx-09), Como, Italy.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm est...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TempoTapMaxAgreement = class Algo(Algorithm)| TempoTapMaxAgreement||| Inputs:|| [vector_vector_real] tickCandidates - the tick candidates estimated using different beat trackers (or features) [s]||| Outputs:|| [vector_real] ticks - the list of resulting ticks [s]| [real] confidence - confidence with which the ticks were detected [0, 5.32]||| Description:|| This algorithm outputs beat positions and confidence of their estimation| based on the maximum mutual agreement between beat candidates estimated by| different beat trackers (or using different features).|| Note that the input tick times should be in ascending order and that they| cannot contain negative values otherwise an exception will be thrown.|| References:| [1] J. R. Zapata, A. Holzapfel, M. E. Davies, J. L. Oliveira, and| F. Gouyon, "Assigning a confidence threshold on automatic beat annotation| in large datasets," in International Society for Music Information| Retrieval Conference (ISMIR’12), 2012.|| [2] A. Holzapfel, M. E. Davies, J. R. Zapata, J. L. Oliveira, and| F. Gouyon, "Selective sampling for beat tracking evaluation," IEEE| Transactions on Audio, Speech, and Language Processing, vol. 13, no. 9,| pp. 2539-2548, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm out...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TempoTapTicks = class Algo(Algorithm)| TempoTapTicks||| Inputs:|| [vector_real] periods - tempo period candidates for the current frame, in frames| [vector_real] phases - tempo ticks phase candidates for the current frame, in frames||| Outputs:|| [vector_real] ticks - the list of resulting ticks [s]| [vector_real] matchingPeriods - list of matching periods [s]||| Parameters:|| frameHop:| integer ∈ (0,inf) (default = 512)| number of feature frames separating two evaluations|| hopSize:| integer ∈ (0,inf) (default = 256)| number of audio samples per features|| sampleRate:| real ∈ (0,inf) (default = 44100)| sampling rate of the audio signal [Hz]||| Description:|| This algorithm builds the list of ticks from the period and phase candidates| given by the TempoTap algorithm.|| Quality: outdated (use TempoTapDegara instead)|| References:| [1] F. Gouyon, "A computational approach to rhythm description: Audio| features for the computation of rhythm periodicity functions and their use| in tempo induction and music content processing," UPF, Barcelona, Spain,| 2005.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Rhythm', 'description': 'This algorithm bui...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TensorflowInputMusiCNN = class Algo(Algorithm)| TensorflowInputMusiCNN||| Inputs:|| [vector_real] frame - the audio frame||| Outputs:|| [vector_real] bands - the log compressed mel bands||| Description:|| This algorithm computes mel-bands with a particular parametrization specific| to MusiCNN based models.|| References:| [1] Pons, J., & Serra, X. (2019). musicnn: Pre-trained convolutional neural| networks for music audio tagging. arXiv preprint arXiv:1909.06654.|| [2] Supported models at https://essentia.upf.edu/models/|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TensorflowInputVGGish = class Algo(Algorithm)| TensorflowInputVGGish||| Inputs:|| [vector_real] frame - the audio frame||| Outputs:|| [vector_real] bands - the log compressed mel bands||| Description:|| This algorithm computes mel-bands with a particular parametrization specific| to VGGish based models.|| References:| [1] Gemmeke, J. et. al., AudioSet: An ontology and human-labelled dataset| for audio events, ICASSP 2017|| [2] Hershey, S. et. al., CNN Architectures for Large-Scale Audio| Classification, ICASSP 2017|| [3] Supported models at https://essentia.upf.edu/models/|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TonalExtractor = class Algo(Algorithm)| TonalExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [real] chords_changes_rate - See ChordsDescriptors algorithm documentation| [vector_real] chords_histogram - See ChordsDescriptors algorithm documentation| [string] chords_key - See ChordsDescriptors algorithm documentation| [real] chords_number_rate - See ChordsDescriptors algorithm documentation| [vector_string] chords_progression - See ChordsDetection algorithm documentation| [string] chords_scale - See ChordsDetection algorithm documentation| [vector_real] chords_strength - See ChordsDetection algorithm documentation| [vector_vector_real] hpcp - See HPCP algorithm documentation| [vector_vector_real] hpcp_highres - See HPCP algorithm documentation| [string] key_key - See Key algorithm documentation| [string] key_scale - See Key algorithm documentation| [real] key_strength - See Key algorithm documentation||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 4096)| the framesize for computing tonal features|| hopSize:| integer ∈ (0,inf) (default = 2048)| the hopsize for computing tonal features|| tuningFrequency:| real ∈ (0,inf) (default = 440)| the tuning frequency of the input signal||| Description:|| This algorithm computes tonal features for an audio signal|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm comp...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TonicIndianArtMusic = class Algo(Algorithm)| TonicIndianArtMusic||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] tonic - the estimated tonic frequency [Hz]||| Parameters:|| binResolution:| real ∈ (0,inf) (default = 10)| salience function bin resolution [cents]|| frameSize:| integer ∈ (0,inf) (default = 2048)| the frame size for computing pitch saliecnce|| harmonicWeight:| real ∈ (0,1) (default = 0.850000023842)| harmonic weighting parameter (weight decay ratio between two consequent| harmonics, =1 for no decay)|| hopSize:| integer ∈ (0,inf) (default = 512)| the hop size with which the pitch salience function was computed|| magnitudeCompression:| real ∈ (0,1] (default = 1)| magnitude compression parameter (=0 for maximum compression, =1 for no| compression)|| magnitudeThreshold:| real ∈ [0,inf) (default = 40)| peak magnitude threshold (maximum allowed difference from the highest peak| in dBs)|| maxTonicFrequency:| real ∈ [0,inf) (default = 375)| the maximum allowed tonic frequency [Hz]|| minTonicFrequency:| real ∈ [0,inf) (default = 100)| the minimum allowed tonic frequency [Hz]|| numberHarmonics:| integer ∈ [1,inf) (default = 20)| number of considered hamonics|| numberSaliencePeaks:| integer ∈ [1, 15] (default = 5)| number of top peaks of the salience function which should be considered| for constructing histogram|| referenceFrequency:| real ∈ (0,inf) (default = 55)| the reference frequency for Hertz to cent convertion [Hz], corresponding to| the 0th cent bin|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]||| Description:|| This algorithm estimates the tonic frequency of the lead artist in Indian art| music. It uses multipitch representation of the audio signal (pitch salience)| to compute a histogram using which the tonic is identified as one of its| peak. The decision is made based on the distance between the prominent peaks,| the classification is done using a decision tree.|| References:| [1] J. Salamon, S. Gulati, and X. Serra, "A Multipitch Approach to Tonic| Identification in Indian Classical Music," in International Society for| Music Information Retrieval Conference (ISMIR’12), 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TriangularBands = class Algo(Algorithm)| TriangularBands||| Inputs:|| [vector_real] spectrum - the input spectrum (must be greater than size one)||| Outputs:|| [vector_real] bands - the energy in each band||| Parameters:|| frequencyBands:| vector_real (default = [21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594])| list of frequency ranges into which the spectrum is divided (these must be| in ascending order and connot contain duplicates),each triangle is build as| x(i-1)=0, x(i)=1, x(i+1)=0 over i, the resulting number of bands is size of| input array - 2|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of the spectrum|| log:| bool ∈ {true,false} (default = true)| compute log-energies (log10 (1 + energy))|| normalize:| string ∈ {unit_sum,unit_tri,unit_max} (default = "unit_sum")| spectrum bin weights to use for each triangular band: 'unit_max' to make| each triangle vertex equal to 1, 'unit_sum' to make each triangle area| equal to 1 summing the actual weights of spectrum bins, 'unit_area' to make| each triangle area equal to 1 normalizing the weights of each triangle by| its bandwidth|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| type:| string ∈ {magnitude,power} (default = "power")| use magnitude or power spectrum|| weighting:| string ∈ {linear,slaneyMel,htkMel} (default = "linear")| type of weighting function for determining triangle area||| Description:|| This algorithm computes energy in triangular frequency bands of a spectrum.| The arbitrary number of overlapping bands can be specified. For each band the| power-spectrum (mag-squared) is summed.|| Parameter "frequencyBands" must contain at least two frequencies, they all| must be positive and must be ordered ascentdantly, otherwise an exception| will be thrown. TriangularBands is only defined for spectrum, which size is| greater than 1.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TriangularBarkBands = class Algo(Algorithm)| TriangularBarkBands||| Inputs:|| [vector_real] spectrum - the audio spectrum||| Outputs:|| [vector_real] bands - the energy in bark bands||| Parameters:|| highFrequencyBound:| real ∈ [0,inf) (default = 22050)| an upper-bound limit for the frequencies to be included in the bands|| inputSize:| integer ∈ (1,inf) (default = 1025)| the size of the spectrum|| log:| bool ∈ {true,false} (default = false)| compute log-energies (log10 (1 + energy))|| lowFrequencyBound:| real ∈ [0,inf) (default = 0)| a lower-bound limit for the frequencies to be included in the bands|| normalize:| string ∈ {unit_sum,unit_max} (default = "unit_sum")| 'unit_max' makes the vertex of all the triangles equal to 1, 'unit_sum'| makes the area of all the triangles equal to 1|| numberBands:| integer ∈ (1,inf) (default = 24)| the number of output bands|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sample rate|| type:| string ∈ {magnitude,power} (default = "power")| 'power' to output squared units, 'magnitude' to keep it as the input|| weighting:| string ∈ {warping,linear} (default = "warping")| type of weighting function for determining triangle area||| Description:|| This algorithm computes energy in the bark bands of a spectrum. It is| different to the regular BarkBands algorithm in that is more configurable so| that it can be used in the BFCC algorithm to produce output similar to| Rastamat (http://www.ee.columbia.edu/ln/rosa/matlab/rastamat/)| See the BFCC algorithm documentation for more information as to why you might| want to choose this over Mel frequency analysis| It is recommended that the input "spectrum" be calculated by the Spectrum| algorithm.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Spectral', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Trimmer = class Algo(Algorithm)| Trimmer||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [vector_real] signal - the trimmed signal||| Parameters:|| checkRange:| bool ∈ {true,false} (default = false)| check whether the specified time range for a slice fits the size of input| signal (throw exception if not)|| endTime:| real ∈ [0,inf) (default = 1000000)| the end time of the slice you want to extract [s]|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the input audio signal [Hz]|| startTime:| real ∈ [0,inf) (default = 0)| the start time of the slice you want to extract [s]||| Description:|| This algorithm extracts a segment of an audio signal given its start and end| times.| Giving "startTime" greater than "endTime" will raise an exception.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm e...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Tristimulus = class Algo(Algorithm)| Tristimulus||| Inputs:|| [vector_real] frequencies - the frequencies of the harmonic peaks ordered by frequency| [vector_real] magnitudes - the magnitudes of the harmonic peaks ordered by frequency||| Outputs:|| [vector_real] tristimulus - a three-element vector that measures the mixture of harmonics of the given spectrum||| Description:|| This algorithm calculates the tristimulus of a signal given its harmonic| peaks. The tristimulus has been introduced as a timbre equivalent to the| color attributes in the vision. Tristimulus measures the mixture of harmonics| in a given sound, grouped into three sections. The first tristimulus measures| the relative weight of the first harmonic; the second tristimulus measures| the relative weight of the second, third, and fourth harmonics taken| together; and the third tristimulus measures the relative weight of all the| remaining harmonics.|| Tristimulus is intended to be fed by the output of the HarmonicPeaks| algorithm. The algorithm throws an exception when the input frequencies are| not in ascending order and/or if the input vectors are of different sizes.|| References:| [1] Tristimulus (audio) - Wikipedia, the free encyclopedia| http://en.wikipedia.org/wiki/Tristimulus_(audio)|| [2] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm calc...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TruePeakDetector = class Algo(Algorithm)| TruePeakDetector||| Inputs:|| [vector_real] signal - the input audio signal||| Outputs:|| [vector_real] peakLocations - the peak locations in the ouput signal| [vector_real] output - the processed signal||| Parameters:|| blockDC:| bool ∈ {true,false} (default = false)| flag to activate the optional DC blocker|| emphasise:| bool ∈ {true,false} (default = false)| flag to activate the optional emphasis filter|| oversamplingFactor:| integer ∈ [1,inf) (default = 4)| times the signal is oversapled|| quality:| integer ∈ [0,4] (default = 1)| type of interpolation applied (see libresmple)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| threshold:| real ∈ (-inf,inf) (default = -0.000199999994948)| threshold to detect peaks [dB]|| version:| integer ∈ {2,4} (default = 4)| algorithm version||| Description:|| This algorithm implements a “true-peak” level meter for clipping| detection. According to the ITU-R recommendations, “true-peak” values| overcoming the full-scale range are potential sources of “clipping in| subsequent processes, such as within particular D/A converters or during| sample-rate conversion”.| The ITU-R BS.1770-4[1] (by default) and the ITU-R BS.1770-2[2] signal-flows| can be used. Go to the references for information about the differences.| Only the peaks (if any) exceeding the configurable amplitude threshold are| returned.| Note: the parameters 'blockDC' and 'emphasise' work only when 'version' is| set to 2.| References:| [1] Series, B. S. (2011). Recommendation ITU-R BS.1770-4. Algorithms to| measure audio programme loudness and true-peak audio level,| https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.1770-4-201510-I!!PDF-E.| [2] Series, B. S. (2011). Recommendation ITU-R BS.1770-2. Algorithms to| measure audio programme loudness and true-peak audio level,| https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.1770-2-201103-S!!PDF-E.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Audio Problems', 'description': 'This algor...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TuningFrequency = class Algo(Algorithm)| TuningFrequency||| Inputs:|| [vector_real] frequencies - the frequencies of the spectral peaks [Hz]| [vector_real] magnitudes - the magnitudes of the spectral peaks||| Outputs:|| [real] tuningFrequency - the tuning frequency [Hz]| [real] tuningCents - the deviation from 440 Hz (between -35 to 65 cents)||| Parameters:|| resolution:| real ∈ (0,inf) (default = 1)| resolution in cents (logarithmic scale, 100 cents = 1 semitone) for tuning| frequency determination||| Description:|| This algorithm estimates the tuning frequency give a sequence/set of spectral| peaks. The result is the tuning frequency in Hz, and its distance from 440Hz| in cents. This version is slightly adapted from the original algorithm [1],| but gives the same results.|| Input vectors should have the same size, otherwise an exception is thrown.| This algorithm should be given the outputs of the spectral peaks algorithm.|| Application: Western vs non-western music classification, key estimation,| HPCP computation, tonal similarity.| References:| [1] E. Gómez, "Key estimation from polyphonic audio," in Music Information| Retrieval Evaluation Exchange (MIREX’05), 2005.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm esti...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).TuningFrequencyExtractor = class Algo(Algorithm)| TuningFrequencyExtractor||| Inputs:|| [vector_real] signal - the audio input signal||| Outputs:|| [vector_real] tuningFrequency - the computed tuning frequency||| Parameters:|| frameSize:| integer ∈ (0,inf) (default = 4096)| the frameSize for computing tuning frequency|| hopSize:| integer ∈ (0,inf) (default = 2048)| the hopsize for computing tuning frequency||| Description:|| This algorithm extracts the tuning frequency of an audio signal|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Tonal', 'description': 'This algorithm extr...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).UnaryOperator = class Algo(Algorithm)| UnaryOperator||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] array - the input array transformed by unary operation||| Parameters:|| scale:| real ∈ (-inf,inf) (default = 1)| multiply result by factor|| shift:| real ∈ (-inf,inf) (default = 0)| shift result by value (add value)|| type:| string ∈ {identity,abs,log10,log,ln,lin2db,db2lin,sin,cos,sqrt,square} (default = "identity")| the type of the unary operator to apply to input array||| Description:|| This algorithm performs basic arithmetical operations element by element| given an array.| Note:| - log and ln are equivalent to the natural logarithm| - for log, ln, log10 and lin2db, x is clipped to 1e-30 for x<1e-30| - for x<0, sqrt(x) is invalid| - scale and shift parameters define linear transformation to be applied to| the resulting elements|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm p...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).UnaryOperatorStream = class Algo(Algorithm)| UnaryOperatorStream||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [vector_real] array - the input array transformed by unary operation||| Parameters:|| scale:| real ∈ (-inf,inf) (default = 1)| multiply result by factor|| shift:| real ∈ (-inf,inf) (default = 0)| shift result by value (add value)|| type:| string ∈ {identity,abs,log10,log,ln,lin2db,db2lin,sin,cos,sqrt,square} (default = "identity")| the type of the unary operator to apply to input array||| Description:|| This algorithm performs basic arithmetical operations element by element| given an array.| Note:| - log and ln are equivalent to the natural logarithm| - for log, ln, log10 and lin2db, x is clipped to 1e-30 for x<1e-30| - for x<0, sqrt(x) is invalid| - scale and shift parameters define linear transformation to be applied to| the resulting elements|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm p...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Variance = class Algo(Algorithm)| Variance||| Inputs:|| [vector_real] array - the input array||| Outputs:|| [real] variance - the variance of the input array||| Description:|| This algorithm computes the variance of an array.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Vibrato = class Algo(Algorithm)| Vibrato||| Inputs:|| [vector_real] pitch - the pitch trajectory [Hz].||| Outputs:|| [vector_real] vibratoFrequency - estimated vibrato frequency (or speed) [Hz]; zero if no vibrato was detected.| [vector_real] vibratoExtend - estimated vibrato extent (or depth) [cents]; zero if no vibrato was detected.||| Parameters:|| maxExtend:| real ∈ (0,inf) (default = 250)| maximum considered vibrato extent [cents]|| maxFrequency:| real ∈ (0,inf) (default = 8)| maximum considered vibrato frequency [Hz]|| minExtend:| real ∈ (0,inf) (default = 50)| minimum considered vibrato extent [cents]|| minFrequency:| real ∈ (0,inf) (default = 4)| minimum considered vibrato frequency [Hz]|| sampleRate:| real ∈ (0,inf) (default = 344.53125)| sample rate of the input pitch contour||| Description:|| This algorithm detects the presence of vibrato and estimates its parameters| given a pitch contour [Hz]. The result is the vibrato frequency in Hz and the| extent (peak to peak) in cents. If no vibrato is detected in a frame, the| output of both values is zero.|| This algorithm should be given the outputs of a pitch estimator, i.e.| PredominantMelody, PitchYinFFT or PitchMelodia and the corresponding sample| rate with which it was computed.|| The algorithm is an extended version of the vocal vibrato detection in| PerdominantMelody.| References:| [1] J. Salamon and E. Gómez, "Melody extraction from polyphonic music| signals using pitch contour characteristics," IEEE Transactions on Audio,| Speech, and Language Processing, vol. 20, no. 6, pp. 1759–1770, 2012.|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Pitch', 'description': 'This algorithm dete...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Viterbi = class Algo(Algorithm)| Viterbi||| Inputs:|| [vector_vector_real] observationProbabilities - the observation probabilities| [vector_real] initialization - the initialization| [undefined] fromIndex - the transition matrix from index| [undefined] toIndex - the transition matrix to index| [vector_real] transitionProbabilities - the transition probabilities matrix||| Outputs:|| [vector_integer] path - the decoded path||| Description:|| This algorithm estimates the most-likely path by Viterbi algorithm. It is| used in PitchYinProbabilistiesHMM algorithm.|| This Viterbi algorithm returns the most likely path. The internal variable| calculation uses double for a better precision.|| References:| [1] M. Mauch and S. Dixon, "pYIN: A Fundamental Frequency Estimator| Using Probabilistic Threshold Distributions," in Proceedings of the| IEEE International Conference on Acoustics, Speech, and Signal Processing| (ICASSP 2014)Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Statistics', 'description': 'This algorithm...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).WarpedAutoCorrelation = class Algo(Algorithm)| WarpedAutoCorrelation||| Inputs:|| [vector_real] array - the array to be analyzed||| Outputs:|| [vector_real] warpedAutoCorrelation - the warped auto-correlation vector||| Parameters:|| maxLag:| integer ∈ (0,inf) (default = 1)| the maximum lag for which the auto-correlation is computed (inclusive)| (must be smaller than signal size)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the audio sampling rate [Hz]||| Description:|| This algorithm computes the warped auto-correlation of an audio signal. The| implementation is an adapted version of K. Schmidt's implementation of the| matlab algorithm from the 'warped toolbox' by Aki Harma and Matti Karjalainen| found [2]. For a detailed explanation of the algorithm, see [1].| This algorithm is only defined for positive lambda =| 1.0674*sqrt(2.0*atan(0.00006583*sampleRate)/PI) - 0.1916, thus it will throw| an exception when the supplied sampling rate does not pass the requirements.| If maxLag is larger than the size of the input array, an exception is thrown.|| References:| [1] A. Härmä, M. Karjalainen, L. Savioja, V. Välimäki, U. K. Laine, and| J. Huopaniemi, "Frequency-Warped Signal Processing for Audio Applications,"| JAES, vol. 48, no. 11, pp. 1011–1031, 2000.|| [2] WarpTB - Matlab Toolbox for Warped DSP| http://www.acoustics.hut.fi/software/warp|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Welch = class Algo(Algorithm)| Welch||| Inputs:|| [vector_real] frame - the input stereo audio signal||| Outputs:|| [vector_real] psd - Power Spectral Density [dB] or [dB/Hz]||| Parameters:|| averagingFrames:| integer ∈ (0,inf) (default = 10)| amount of frames to average|| fftSize:| integer ∈ (0,inf) (default = 1024)| size of the FFT. Zero padding is added if this is larger the input frame| size.|| frameSize:| integer ∈ (0,inf) (default = 512)| the expected size of the input audio signal (this is an optional parameter| to optimize memory allocation)|| sampleRate:| real ∈ (0,inf) (default = 44100)| the sampling rate of the audio signal [Hz]|| scaling:| string ∈ {density,power} (default = "density")| 'density' normalizes the result to the bandwidth while 'power' outputs the| unnormalized power spectrum|| windowType:| string ∈ {hamming,hann,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'||| Description:|| This algorithm estimates the Power Spectral Density of the input signal| using the Welch's method [1].| The input should be fed with the overlapped audio frames. The algorithm| stores internally therequired past frames to compute each output. Call| reset() to clear the buffers. This implentation is based on Scipy [2]|| References:| [1] The Welch's method - Wikipedia, the free encyclopedia,| https://en.wikipedia.org/wiki/Welch%27s_method| [2]| https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.signal.welch| .html|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': ' This algorithm ...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).Windowing = class Algo(Algorithm)| Windowing||| Inputs:|| [vector_real] frame - the input audio frame||| Outputs:|| [vector_real] frame - the windowed audio frame||| Parameters:|| normalized:| bool ∈ {true,false} (default = true)| a boolean value to specify whether to normalize windows (to have an area of| 1) and then scale by a factor of 2|| size:| integer ∈ [2,inf) (default = 1024)| the window size|| type:| string ∈ {hamming,hann,hannnsgcq,triangular,square,blackmanharris62,blackmanharris70,blackmanharris74,blackmanharris92} (default = "hann")| the window type, which can be 'hamming', 'hann', 'triangular', 'square' or| 'blackmanharrisXX'|| zeroPadding:| integer ∈ [0,inf) (default = 0)| the size of the zero-padding|| zeroPhase:| bool ∈ {true,false} (default = true)| a boolean value that enables zero-phase windowing||| Description:|| This algorithm applies windowing to an audio signal. It optionally applies| zero-phase windowing and optionally adds zero-padding. The resulting windowed| frame size is equal to the incoming frame size plus the number of padded| zeros. By default, the available windows are normalized (to have an area of| 1) and then scaled by a factor of 2.|| An exception is thrown if the size of the frame is less than 2.|| References:| [1] F. J. Harris, "On the use of windows for harmonic analysis with the| discrete Fourier transform, Proceedings of the IEEE, vol. 66, no. 1,| pp. 51-83, Jan. 1978|| [2] Window function - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Window_function|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm a...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).YamlInput = class Algo(Algorithm)| YamlInput||| Outputs:|| [pool] pool - Pool of deserialized values||| Parameters:|| filename:| string| Input filename|| format:| string ∈ {json,yaml} (default = "yaml")| whether to the input file is in JSON or YAML format||| Description:|| This algorithm deserializes a file formatted in YAML to a Pool. This file can| be serialized back into a YAML file using the YamlOutput algorithm. See the| documentation for YamlOutput for more information on the specification of the| YAML file.|| Note: If an empty sequence is encountered (i.e. "[]"), this algorithm will| assume it was intended to be a sequence of Reals and will add it to the| output pool accordingly. This only applies to sequences which contain empty| sequences. Empty sequences (which are not subsequences) are not possible in a| Pool and therefore will be ignored if encountered (i.e. foo: [] (ignored),| but foo: [[]] (added as a vector of one empty vector of reals).|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).YamlOutput = class Algo(Algorithm)| YamlOutput||| Inputs:|| [pool] pool - Pool to serialize into a YAML formatted file||| Parameters:|| doubleCheck:| bool (default = false)| whether to double-check if the file has been correctly written to the disk|| filename:| string (default = "-")| output filename (use '-' to emit to stdout)|| format:| string ∈ {json,yaml} (default = "yaml")| whether to output data in JSON or YAML format|| indent:| integer (default = 4)| (json only) how many characters to indent each line, or 0 for no newlines|| writeVersion:| bool (default = true)| whether to write the essentia version to the output file||| Description:|| This algorithm emits a YAML or JSON representation of a Pool.|| Each descriptor key in the Pool is decomposed into different nodes of the| YAML (JSON) format by splitting on the '.' character. For example a Pool that| looks like this:|| foo.bar.some.thing: [23.1, 65.2, 21.3]|| will be emitted as:|| metadata:| essentia:| version: <version-number>|| foo:| bar:| some:| thing: [23.1, 65.2, 21.3]|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Input/output', 'description': 'This algorit...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).ZeroCrossingRate = class Algo(Algorithm)| ZeroCrossingRate||| Inputs:|| [vector_real] signal - the input signal||| Outputs:|| [real] zeroCrossingRate - the zero-crossing rate||| Parameters:|| threshold:| real ∈ [0,inf] (default = 0)| the threshold which will be taken as the zero axis in both positive and| negative sign||| Description:|| This algorithm computes the zero-crossing rate of an audio signal. It is the| number of sign changes between consecutive signal values divided by the total| number of values. Noisy signals tend to have higher zero-crossing rate.| In order to avoid small variations around zero caused by noise, a threshold| around zero is given to consider a valid zerocrosing whenever the boundary is| crossed.|| Empty input signals will raise an exception.|| References:| [1] Zero Crossing - Wikipedia, the free encyclopedia,| http://en.wikipedia.org/wiki/Zero-crossing_rate|| [2] G. Peeters, "A large set of audio features for sound description| (similarity and classification) in the CUIDADO project," CUIDADO I.S.T.| Project Report, 2004|| Method resolution order:| Algo| Algorithm| builtins.object|| Methods defined here:|| __call__(self, *args)|| __init__(self, **kwargs)|| __str__(self)|| compute(self, *args)|| configure(self, **kwargs)|| ----------------------------------------------------------------------| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)|| ----------------------------------------------------------------------| Data and other attributes defined here:|| __struct__ = {'category': 'Standard', 'description': 'This algorithm c...|| ----------------------------------------------------------------------| Methods inherited from Algorithm:|| __compute__(...)| compute the algorithm|| __configure__(...)| Configure the algorithm|| __new__(*args, **kwargs) from builtins.type| Create and return a new object. See help(type) for accurate signature.|| getDoc(...)| Returns the doc string for the algorithm|| getStruct(...)| Returns the doc struct for the algorithm|| inputNames(...)| Returns the names of the inputs of the algorithm.|| inputType(...)| Returns the type of the input given by its name|| name(...)| Returns the name of the algorithm.|| outputNames(...)| Returns the names of the outputs of the algorithm.|| paramType(...)| Returns the type of the parameter given by its name|| paramValue(...)| Returns the value of the parameter or None if not yet configured|| parameterNames(...)| Returns the names of the parameters for this algorithm.|| reset(...)| Reset the algorithm to its initial state (if any).
FUNCTIONS algorithmInfo = info(...) returns all the information about a given classic algorithm.
xxxxxxxxxxalgorithmNames = keys(...)returns algorithm names
FILE /home/stelios/.local/lib/python3.6/site-packages/essentia/standard.py